cycode 3.25.1.dev5__py3-none-any.whl → 3.25.2.dev1__py3-none-any.whl

cycode/__init__.py

@@ -5,4 +5,4 @@ import time as _time
 # end-to-end scan duration from the moment the user actually triggered it.
 _BOOT_WALL: float = _time.time()
 
-__version__ = '3.25.1.dev5'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag
+__version__ = '3.25.2.dev1'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag

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

@@ -35,23 +35,22 @@ def get_ide(name: str) -> IDE:
     return ide
 
 
-def collect_all_session_contexts() -> tuple[dict[str, dict], dict]:
+def collect_all_session_contexts() -> tuple[list[dict], dict]:
     """Sweep every registered IDE's session context, regardless of which IDE triggered the hook.
 
-    Returns ``(config_files_by_ide, plugins)``: the global MCP config file of each IDE that has
-    one (keyed by IDE name), and the enabled plugins merged across IDEs (first registered IDE
-    wins on a duplicate plugin key - plugins are IDE-agnostic marketplace artifacts).
+    Returns ``(config_files, plugins)``: the global MCP config files of every IDE, and the
+    enabled plugins merged across IDEs (first registered IDE wins on a duplicate plugin key -
+    plugins are IDE-agnostic marketplace artifacts).
     """
-    config_files_by_ide: dict[str, dict] = {}
+    config_files: list[dict] = []
     plugins: dict = {}
     for ide in IDES.values():
-        global_config_file, enabled_plugins = ide.get_session_context()
-        if global_config_file:
-            config_files_by_ide[ide.name] = global_config_file
+        global_config_files, enabled_plugins = ide.get_session_context()
+        config_files.extend(global_config_files)
         for plugin_key, plugin in (enabled_plugins or {}).items():
             plugins.setdefault(plugin_key, plugin)
 
-    return config_files_by_ide, plugins
+    return config_files, plugins
 
 
 def collect_all_skills() -> list[dict]:

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

@@ -42,17 +42,17 @@ def load_plugin_json(path: Path) -> Optional[dict]:
         return None
 
 
-def build_global_config_file(path: Path, mcp_servers: Optional[dict]) -> Optional[dict]:
+def build_global_config_files(path: Path, mcp_servers: Optional[dict]) -> list[dict]:
     """Wrap a global (non-plugin) MCP config into the session-context file shape.
 
-    Returns ``{"path": <full path>, "content": <{"mcpServers": ...} JSON>}`` when
-    there are servers, else ``None``. ``content`` is normalized to the canonical
+    Returns ``[{"path": <full path>, "content": <{"mcpServers": ...} JSON>}]`` when
+    there are servers, else ``[]``. ``content`` is normalized to the canonical
     ``{"mcpServers": {...}}`` shape, dropping everything else in the source file.
     """
-    servers = mcp_servers or {}
+    servers = mcp_servers if isinstance(mcp_servers, dict) else {}
     if not servers:
-        return None
-    return {'path': str(path), 'content': json.dumps({'mcpServers': servers})}
+        return []
+    return [{'path': str(path), 'content': json.dumps({'mcpServers': servers})}]
 
 
 def walk_enabled_plugins(

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

@@ -176,19 +176,19 @@ class IDE(ABC):
         """
         return None
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
-        """Return ``(global_config_file, enabled_plugins)`` for session-context reporting.
+    def get_session_context(self) -> tuple[list[dict], dict]:
+        """Return ``(global_config_files, enabled_plugins)`` for session-context reporting.
 
-        ``global_config_file`` is the IDE's global (non-plugin) MCP config as
-        ``{"path": <full path>, "content": <normalized {"mcpServers": ...} JSON>}``,
-        or ``None`` when there is no global MCP config. ``enabled_plugins`` maps each
-        enabled plugin key to its metadata (including its own ``mcp_config_file``
-        content and ``mcp_config_file_path``).
+        ``global_config_files`` are the IDE's global (non-plugin) MCP configs, each as
+        ``{"path": <full path>, "content": <normalized {"mcpServers": ...} JSON>}``;
+        empty when there is none. ``enabled_plugins`` maps each enabled plugin key to
+        its metadata (including its own ``mcp_config_file`` content and
+        ``mcp_config_file_path``).
 
-        Default: ``(None, {})`` (no plugin system, no discoverable MCP config).
+        Default: ``([], {})`` (no plugin system, no discoverable MCP config).
         Override to surface MCP/plugin inventory.
         """
-        return None, {}
+        return [], {}
 
     def get_skills(self) -> list[dict]:
         """Return the IDE's user-scope skills as ``[{"path", "content"}]``.
@@ -198,7 +198,7 @@ class IDE(ABC):
         read these files off endpoints can only ever return raw content.
 
         Kept separate from ``get_session_context`` rather than folded into its
-        ``global_config_file`` slot, which is normalized to an MCP server map.
+        ``global_config_files``, which are normalized to an MCP server map.
 
         Default: ``[]`` (the IDE has no skill system). Override to surface skills.
         """

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

@@ -1,6 +1,7 @@
 """Claude Code IDE integration for AI guardrails."""
 
 import json
+import re
 from collections.abc import Iterator
 from copy import deepcopy
 from pathlib import Path
@@ -8,7 +9,7 @@ from typing import ClassVar, Optional
 
 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,
@@ -253,6 +254,41 @@ def resolve_plugins(settings: dict) -> dict:
     )
 
 
+def _sanitize_mcp_name(name: str) -> str:
+    """Mirrors how Claude Code sanitizes a server name inside a tool name."""
+    return re.sub(r'[^a-z0-9_-]', '_', name.lower())
+
+
+def _local_mcp_servers(config: Optional[dict], cwd: Optional[str]) -> Iterator[tuple[str, str]]:
+    """Yield ``(name as Claude Code namespaces it, config key)`` for each locally configured MCP server."""
+    sources = []
+    if config:
+        sources.append(get_mcp_servers(config))
+        if cwd:
+            sources.append(((config.get('projects') or {}).get(cwd) or {}).get('mcpServers'))
+    if cwd:
+        sources.append((load_plugin_json(Path(cwd) / '.mcp.json') or {}).get('mcpServers'))
+    for servers in sources:
+        if isinstance(servers, dict):
+            for name in servers:
+                yield name, name
+
+    settings = load_claude_settings()
+    for plugin_key, entry in (resolve_plugins(settings) if settings else {}).items():
+        plugin_name = plugin_key.split('@', 1)[0]
+        for server in entry.get('mcp_server_names') or []:
+            yield f'plugin_{plugin_name}_{server}', server
+
+
+def _resolve_mcp_server_name(server: str, config: Optional[dict], cwd: Optional[str]) -> str:
+    """Map the server segment of ``mcp__<server>__<tool>`` back to its config key; unknown names pass through."""
+    wanted = _sanitize_mcp_name(server)
+    for namespaced, name in _local_mcp_servers(config, cwd):
+        if _sanitize_mcp_name(namespaced) == wanted:
+            return name
+    return server
+
+
 # --- IDE integration ----------------------------------------------------------
 
 
@@ -339,6 +375,8 @@ class ClaudeCode(IDE):
 
         config = load_claude_config()
         ide_user_email = _email_from_config(config) if config else None
+        if mcp_server_name:
+            mcp_server_name = _resolve_mcp_server_name(mcp_server_name, config, raw_payload.get('cwd'))
 
         return AIHookPayload(
             event_name=canonical_event,
@@ -396,14 +434,14 @@ class ClaudeCode(IDE):
         config = load_claude_config()
         return _email_from_config(config) if config else None
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
+    def get_session_context(self) -> tuple[list[dict], dict]:
         config = load_claude_config()
-        global_config_file = build_global_config_file(_CLAUDE_CONFIG_PATH, get_mcp_servers(config)) if config else None
+        global_config_files = build_global_config_files(_CLAUDE_CONFIG_PATH, get_mcp_servers(config)) if config else []
 
         settings = load_claude_settings()
         enriched_plugins = resolve_plugins(settings) if settings else {}
 
-        return global_config_file, enriched_plugins
+        return global_config_files, enriched_plugins
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_claude_skills_dir())

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

@@ -2,7 +2,9 @@
 
 import json
 import os
+import re
 import sys
+from collections.abc import Iterator
 from pathlib import Path
 from typing import ClassVar, Optional
 
@@ -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,
@@ -158,6 +160,42 @@ def _resolve_codex_plugins(config: dict) -> dict:
     )
 
 
+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[Optional[str], Optional[str]]:
+    """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: Optional[tuple[int, str]] = 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: Optional[Path] = None) -> tuple[bool, str]:
     """Set ``[features] hooks = true`` in Codex's ``config.toml``.
 
@@ -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(
@@ -302,17 +336,17 @@ class Codex(IDE):
     def get_user_email(self) -> Optional[str]:
         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

@@ -33,7 +33,7 @@ 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,
 )
@@ -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
@@ -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

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import ClassVar, Optional
 
 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
@@ -64,6 +64,44 @@ 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) -> Optional[str]:
+    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) -> Optional[str]:
+    """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'
@@ -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/scan/guardrail_config.py

@@ -3,7 +3,7 @@
 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
@@ -23,7 +23,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 +34,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)
 
@@ -60,10 +70,20 @@ class GuardrailConfig:
             if guardrail.get('key') in _KNOWN_GUARDRAIL_KEYS
         }
 
+    @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: Optional[str]) -> 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:
         return [
@@ -87,8 +107,7 @@ 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:
         """Expired, or fetched for another tenant (the user switched tenants since)."""
@@ -99,14 +118,14 @@ def apply_platform_config(policy: dict, config: Optional[GuardrailConfig], ide_n
     """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,7 +142,11 @@ 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:

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

@@ -10,10 +10,9 @@ touching any handler in this module.
 
 import json
 import os
+import threading
 from dataclasses import dataclass
-from multiprocessing.pool import ThreadPool
-from multiprocessing.pool import TimeoutError as PoolTimeoutError
-from typing import TYPE_CHECKING, Callable, NamedTuple, Optional
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Optional
 
 import typer
 
@@ -22,6 +21,7 @@ if TYPE_CHECKING:
 
 from cycode.cli.apps.ai_guardrails.consts import GuardrailsMode, PolicyMode
 from cycode.cli.apps.ai_guardrails.ides.base import HookDecision
+from cycode.cli.apps.ai_guardrails.scan.mcp_server_status import is_enforced, load_mcp_server_statuses
 from cycode.cli.apps.ai_guardrails.scan.payload import AIHookPayload
 from cycode.cli.apps.ai_guardrails.scan.policy import get_policy_value
 from cycode.cli.apps.ai_guardrails.scan.types import (
@@ -218,6 +218,16 @@ class _ArgScanFeature:
     deny_agent_message: str
     ask_message: Callable[[str], str]
     ask_agent_message: str
+    scan_enabled: bool = True
+
+
+class _PreScanFinding(NamedTuple):
+    """A finding on the call itself (e.g. an unauthorized MCP server), made before the text scan."""
+
+    block_reason: BlockReason
+    mode: GuardrailsMode
+    deny_message: str
+    deny_agent_message: str
 
 
 def _handle_arg_scan(
@@ -226,8 +236,12 @@ def _handle_arg_scan(
     policy: dict,
     feature: _ArgScanFeature,
     scan_text: str,
+    pre_scan_finding: Optional[_PreScanFinding] = None,
 ) -> HookDecision:
-    """Shared scan + decision flow for MCP_EXECUTION and COMMAND_EXEC events."""
+    """Shared scan + decision flow for MCP_EXECUTION and COMMAND_EXEC events.
+
+    A Report-mode pre-scan finding still scans, and a secret found then takes over the response.
+    """
     ai_client = ctx.obj['ai_security_client']
 
     max_bytes = get_policy_value(policy, 'secrets', 'max_bytes', default=200000)
@@ -240,6 +254,18 @@ def _handle_arg_scan(
     error_message = None
 
     try:
+        if pre_scan_finding is not None:
+            block_reason = pre_scan_finding.block_reason
+            if pre_scan_finding.mode == GuardrailsMode.BLOCK:
+                outcome = AIHookOutcome.BLOCKED
+                return HookDecision.deny(
+                    feature.event_type, pre_scan_finding.deny_message, pre_scan_finding.deny_agent_message
+                )
+            outcome = AIHookOutcome.WARNED
+
+        if not feature.scan_enabled:
+            return HookDecision.allow(feature.event_type)
+
         scan_outcome = _scan_text_for_secrets(
             ctx,
             clipped,
@@ -283,8 +309,43 @@ def _handle_arg_scan(
         )
 
 
+def _check_mcp_server_authorization(payload: AIHookPayload, policy: dict) -> Optional[_PreScanFinding]:
+    """Fails open: no server name or no cached statuses lets the call through."""
+    mcp_config = get_policy_value(policy, 'mcp', default={})
+    if not get_policy_value(mcp_config, 'check_server', default=False):
+        return None
+
+    server_name = payload.mcp_server_name
+    if not server_name:
+        logger.debug('No MCP server name in the payload; skipping the server authorization check')
+        return None
+
+    statuses = load_mcp_server_statuses()
+    if statuses is None:
+        logger.debug('No cached MCP server statuses; skipping the server authorization check')
+        return None
+
+    status = statuses.status_of(server_name)
+    if not is_enforced(status):
+        return None
+
+    logger.debug('MCP server is not authorized, %s', {'mcp_server_name': server_name, 'status': status})
+    return _PreScanFinding(
+        block_reason=BlockReason.UNAUTHORIZED_MCP_SERVER,
+        mode=get_effective_mode(mcp_config, action_key='server_action'),
+        deny_message=(
+            f"Cycode blocked MCP server '{server_name}': it is not authorized in your organization. "
+            'Contact your admin to authorize it.'
+        ),
+        deny_agent_message=(
+            f"The MCP server '{server_name}' is not authorized in this organization. "
+            'Do not retry its tools or reach it another way.'
+        ),
+    )
+
+
 def handle_before_mcp_execution(ctx: typer.Context, payload: AIHookPayload, policy: dict) -> HookDecision:
-    """Scan MCP tool arguments for secrets before execution."""
+    """Check the MCP server is authorized, then scan the tool arguments for secrets."""
     tool = payload.mcp_tool_name or 'unknown'
     args = payload.mcp_arguments or {}
     args_text = args if isinstance(args, str) else json.dumps(args)
@@ -298,8 +359,10 @@ def handle_before_mcp_execution(ctx: typer.Context, payload: AIHookPayload, poli
             deny_agent_message='Do not pass secrets to tools. Use secret references (name/id) instead.',
             ask_message=lambda v: f'Allow MCP tool call "{tool}"? {v}',
             ask_agent_message='Possible secrets detected in tool arguments; proceed with caution.',
+            scan_enabled=get_policy_value(policy, 'mcp', 'scan_args', default=True),
         ),
         scan_text=args_text,
+        pre_scan_finding=_check_mcp_server_authorization(payload, policy),
     )
 
 
@@ -370,6 +433,13 @@ def _setup_scan_context(ctx: typer.Context) -> typer.Context:
     return ctx
 
 
+def _run_scan(scan_func: Callable, documents: list[Document], scan_result: dict[str, Any]) -> None:
+    try:
+        scan_result['value'] = scan_func(documents)
+    except BaseException as e:
+        scan_result['error'] = e
+
+
 def _perform_scan(
     ctx: typer.Context, documents: list[Document], scan_parameters: dict, timeout_seconds: float
 ) -> ScanOutcome:
@@ -384,15 +454,17 @@ def _perform_scan(
         ctx, is_git_diff=False, is_commit_range=False, scan_parameters=scan_parameters
     )
 
-    # Use ThreadPool.apply_async with timeout to abort if scan takes too long
-    # This uses the same ThreadPool mechanism as run_parallel_batched_scan but with timeout support
-    with ThreadPool(processes=1) as pool:
-        result = pool.apply_async(scan_batch_thread_func, (documents,))
-        try:
-            _, error, local_scan_result = result.get(timeout=timeout_seconds)
-        except PoolTimeoutError:
-            logger.debug('Scan timed out after %s seconds', timeout_seconds)
-            raise RuntimeError(f'Scan timed out after {timeout_seconds} seconds') from None
+    scan_result: dict[str, Any] = {}
+    scan_thread = threading.Thread(target=_run_scan, args=(scan_batch_thread_func, documents, scan_result), daemon=True)
+    scan_thread.start()
+    scan_thread.join(timeout_seconds)
+    if scan_thread.is_alive():
+        logger.debug('Scan timed out after %s seconds', timeout_seconds)
+        raise RuntimeError(f'Scan timed out after {timeout_seconds} seconds')
+    if 'error' in scan_result:
+        raise scan_result['error']
+
+    _, error, local_scan_result = scan_result['value']
 
     # Check if scan failed - raise exception to trigger fail_open policy
     if error:

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

@@ -0,0 +1,103 @@
+"""MCP server authorization status cache: session-start writes it, the pre-MCP-execution hook reads it.
+
+An absent or corrupt cache means no status is known, so the guardrail fails open.
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+from marshmallow import EXCLUDE, Schema, fields, post_load
+
+from cycode.cli.apps.ai_guardrails.scan.guardrail_config import DEFAULT_TTL_SECONDS
+from cycode.cli.consts import CYCODE_CONFIGURATION_DIRECTORY
+from cycode.cli.utils.path_utils import atomic_write_text, quarantine_corrupt_file
+from cycode.cyclient.models import McpServerAuthorizationStatus, McpServerStatus, McpServerStatusSchema
+from cycode.logger import get_logger
+
+logger = get_logger('AI Guardrails')
+
+MCP_SERVER_STATUSES_FILE_NAME = 'ai-guardrails-mcp-servers.json'
+
+
+# An alias shared by several servers (e.g. configured differently per device) gets the most restrictive status.
+_RESTRICTIVENESS = {
+    McpServerAuthorizationStatus.AUTHORIZED: 0,
+    McpServerAuthorizationStatus.UNREVIEWED: 1,
+    McpServerAuthorizationStatus.UNAUTHORIZED: 2,
+}
+
+
+def get_mcp_server_statuses_cache_path() -> Path:
+    return Path.home() / CYCODE_CONFIGURATION_DIRECTORY / MCP_SERVER_STATUSES_FILE_NAME
+
+
+def is_enforced(status: Optional[McpServerAuthorizationStatus]) -> bool:
+    """``status`` is None when the platform never saw the server."""
+    return status == McpServerAuthorizationStatus.UNAUTHORIZED
+
+
+@dataclass
+class McpServerStatuses:
+    servers: list[McpServerStatus]
+    fetched_at: float
+    tenant_id: Optional[str] = None
+    ttl_seconds: float = DEFAULT_TTL_SECONDS
+    _by_alias: dict = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        # The platform matches aliases case-insensitively, so the CLI does too.
+        self._by_alias = {}
+        for server in self.servers:
+            if not server.alias:
+                continue
+            key = server.alias.lower()
+            known = self._by_alias.get(key)
+            if known is None or _RESTRICTIVENESS[server.status] > _RESTRICTIVENESS[known]:
+                self._by_alias[key] = server.status
+
+    def status_of(self, alias: str) -> Optional[McpServerAuthorizationStatus]:
+        return self._by_alias.get(alias.lower())
+
+
+class McpServerStatusesSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    servers = fields.List(fields.Nested(McpServerStatusSchema), required=True)
+    fetched_at = fields.Float(required=True)
+    tenant_id = fields.String(allow_none=True, load_default=None)
+    ttl_seconds = fields.Float(allow_none=True, load_default=None)
+
+    @post_load
+    def build_dto(self, data: dict[str, Any], **_) -> McpServerStatuses:
+        data['ttl_seconds'] = data['ttl_seconds'] or DEFAULT_TTL_SECONDS
+        return McpServerStatuses(**data)
+
+
+def save_mcp_server_statuses(
+    servers: list[McpServerStatus], tenant_id: Optional[str], ttl_seconds: float = DEFAULT_TTL_SECONDS
+) -> None:
+    path = get_mcp_server_statuses_cache_path()
+    statuses = McpServerStatuses(servers=servers, fetched_at=time.time(), tenant_id=tenant_id, ttl_seconds=ttl_seconds)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_text(str(path), json.dumps(McpServerStatusesSchema().dump(statuses)))
+    except Exception as e:
+        logger.debug('Failed to save MCP server statuses cache', exc_info=e)
+
+
+def load_mcp_server_statuses() -> Optional[McpServerStatuses]:
+    path = get_mcp_server_statuses_cache_path()
+    if not path.exists():
+        return None
+
+    try:
+        with open(path, encoding='UTF-8') as file:
+            return McpServerStatusesSchema().load(json.load(file))
+    except Exception as e:
+        logger.warning('MCP server statuses cache is corrupt and will be moved aside', exc_info=e)
+        quarantine_corrupt_file(str(path))
+        return None

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

@@ -40,6 +40,7 @@ class BlockReason(StrEnum):
     SECRETS_IN_FILE = 'secrets_in_file'
     SECRETS_IN_MCP_ARGS = 'secrets_in_mcp_args'
     SENSITIVE_PATH = 'sensitive_path'
+    UNAUTHORIZED_MCP_SERVER = 'unauthorized_mcp_server'
     SCAN_FAILURE = 'scan_failure'
 
 

cycode/cli/apps/ai_guardrails/session_start_command.py

@@ -15,7 +15,14 @@ from cycode.cli.apps.ai_guardrails.ides import (
     collect_all_skills,
     get_ide,
 )
-from cycode.cli.apps.ai_guardrails.scan.guardrail_config import load_guardrail_config, save_guardrail_config
+from cycode.cli.apps.ai_guardrails.scan.guardrail_config import (
+    DEFAULT_TTL_SECONDS,
+    GuardrailConfig,
+    load_guardrail_config,
+    save_guardrail_config,
+)
+from cycode.cli.apps.ai_guardrails.scan.mcp_server_status import save_mcp_server_statuses
+from cycode.cli.apps.ai_guardrails.scan.types import BlockReason
 from cycode.cli.apps.ai_guardrails.scan.utils import read_stdin_text, safe_json_parse
 from cycode.cli.apps.auth.auth_common import get_authorization_info
 from cycode.cli.apps.auth.auth_manager import AuthManager
@@ -49,14 +56,21 @@ def _session_context_digest(report: dict) -> str:
     return hashlib.sha256(canonical.encode('utf-8')).hexdigest()
 
 
-def _should_skip_report(digest: str, tenant_id: Optional[str]) -> bool:
+def _report_ttl_seconds(config: Optional[GuardrailConfig]) -> float:
+    """The response carries the MCP server statuses, so the guardrail's TTL applies while it is enabled."""
+    if config is None or config.is_off_for_every_agent(BlockReason.UNAUTHORIZED_MCP_SERVER):
+        return _SESSION_CONTEXT_TTL_SECONDS
+    return config.ttl_seconds
+
+
+def _should_skip_report(digest: str, tenant_id: Optional[str], ttl_seconds: float) -> bool:
     """Skip when the same payload was already sent for this tenant and the TTL hasn't expired."""
     try:
         cache = json.loads(_session_context_cache_path().read_text(encoding='utf-8'))
         return (
             cache.get('hash') == digest
             and cache.get('tenant_id') == tenant_id
-            and time.time() - float(cache.get('sent_at', 0)) < _SESSION_CONTEXT_TTL_SECONDS
+            and time.time() - float(cache.get('sent_at', 0)) < ttl_seconds
         )
     except Exception:
         # Missing/corrupt cache reads as a miss - over-sending is harmless
@@ -78,6 +92,7 @@ def _report_session_context(
     ai_client: 'AISecurityManagerClient',
     user_email: Optional[str],
     tenant_id: Optional[str],
+    config: Optional[GuardrailConfig],
 ) -> None:
     """Report the device + cross-IDE session context to the AI security manager. Never raises.
 
@@ -86,7 +101,7 @@ def _report_session_context(
     until the TTL expires.
     """
     try:
-        config_files_by_ide, enabled_plugins = collect_all_session_contexts()
+        config_files, enabled_plugins = collect_all_session_contexts()
         report = {
             'hostname': get_hostname(),
             'platform_name': get_platform_name(),
@@ -94,7 +109,7 @@ def _report_session_context(
             'serial_number': get_serial_number(),
             'last_login_user': get_last_login_user(),
             # Sorted by path so the digest is stable regardless of IDE registry order.
-            'config_files': sorted(config_files_by_ide.values(), key=lambda f: f['path']),
+            'config_files': sorted(config_files, key=lambda f: f['path']),
             'enabled_plugins': enabled_plugins,
             # Already deduplicated and sorted by path, for the same digest-stability reason.
             # Editing a skill body changes the digest and so re-reports the device's inventory.
@@ -103,12 +118,19 @@ def _report_session_context(
         }
 
         digest = _session_context_digest(report)
-        if _should_skip_report(digest, tenant_id):
+        if _should_skip_report(digest, tenant_id, _report_ttl_seconds(config)):
             logger.debug('Session context unchanged; skipping report')
             return
 
-        if ai_client.report_session_context(**report):
-            _save_report_cache(digest, tenant_id)
+        response = ai_client.report_session_context(**report)
+        if response is None:
+            return
+
+        _save_report_cache(digest, tenant_id)
+        if response.mcp_servers is not None:
+            ttl_seconds = config.ttl_seconds if config is not None else DEFAULT_TTL_SECONDS
+            save_mcp_server_statuses(response.mcp_servers, tenant_id, ttl_seconds)
+            logger.debug('MCP server statuses cache updated')
     except Exception as e:
         logger.debug('Failed to report session context', exc_info=e)
 
@@ -166,14 +188,14 @@ def session_start_command(
     except Exception as e:
         logger.debug('Failed to create conversation during session start', exc_info=e)
 
-    # Report session context (device + cross-IDE MCP servers and plugins)
-    _report_session_context(ai_client, session_payload.ide_user_email, auth_info.tenant_id)
-
     # SessionStart precedes the first prompt hook in every IDE, so scans normally find a cache.
-    _sync_guardrail_config(ai_client, auth_info.tenant_id)
+    config = _sync_guardrail_config(ai_client, auth_info.tenant_id)
+
+    # Report session context (device + cross-IDE MCP servers and plugins)
+    _report_session_context(ai_client, session_payload.ide_user_email, auth_info.tenant_id, config)
 
 
-def _sync_guardrail_config(ai_client: 'AISecurityManagerClient', tenant_id: Optional[str]) -> None:
+def _sync_guardrail_config(ai_client: 'AISecurityManagerClient', tenant_id: Optional[str]) -> Optional[GuardrailConfig]:
     """Refresh the guardrail config cache when it is expired or belongs to another tenant.
 
     Every step here swallows its own failures - a broken cache or an unreachable platform
@@ -182,9 +204,12 @@ def _sync_guardrail_config(ai_client: 'AISecurityManagerClient', tenant_id: Opti
     cached = load_guardrail_config()
     if cached is not None and not cached.needs_refresh(tenant_id):
         logger.debug('Guardrail config cache is fresh, skipping fetch')
-        return
+        return cached
 
     resolved = ai_client.get_resolved_guardrails()
-    if resolved:
-        save_guardrail_config(resolved, tenant_id)
-        logger.debug('Guardrail config cache updated')
+    if not resolved:
+        return cached
+
+    save_guardrail_config(resolved, tenant_id)
+    logger.debug('Guardrail config cache updated')
+    return GuardrailConfig(payload=resolved, fetched_at=time.time(), tenant_id=tenant_id)

cycode/cli/utils/git_proxy.py

@@ -1,5 +1,6 @@
 import types
 from abc import ABC, abstractmethod
+from functools import cache
 from typing import TYPE_CHECKING, Optional
 
 _GIT_ERROR_MESSAGE = """
@@ -10,11 +11,6 @@ You can help Cycode CLI to locate the Git executable
 by setting the GIT_PYTHON_GIT_EXECUTABLE=<path/to/git> environment variable.
 """.strip().replace('\n', ' ')
 
-try:
-    import git
-except ImportError:
-    git = None
-
 if TYPE_CHECKING:
     from git import PathLike, Repo
 
@@ -23,6 +19,16 @@ class GitProxyError(Exception):
     pass
 
 
+# GitPython runs `git version` on import, so it is imported on first use rather than at CLI startup
+@cache
+def _import_git() -> Optional[types.ModuleType]:
+    try:
+        import git
+    except ImportError:
+        return None
+    return git
+
+
 class _AbstractGitProxy(ABC):
     @abstractmethod
     def get_repo(self, path: Optional['PathLike'] = None, *args, **kwargs) -> 'Repo': ...
@@ -52,46 +58,54 @@ class _DummyGitProxy(_AbstractGitProxy):
 
 
 class _GitProxy(_AbstractGitProxy):
+    def __init__(self, git_module: types.ModuleType) -> None:
+        self._git = git_module
+
     def get_repo(self, path: Optional['PathLike'] = None, *args, **kwargs) -> 'Repo':
-        return git.Repo(path, *args, **kwargs)
+        return self._git.Repo(path, *args, **kwargs)
 
     def get_null_tree(self) -> object:
-        return git.NULL_TREE
+        return self._git.NULL_TREE
 
     def get_invalid_git_repository_error(self) -> type[BaseException]:
-        return git.InvalidGitRepositoryError
+        return self._git.InvalidGitRepositoryError
 
     def get_git_command_error(self) -> type[BaseException]:
-        return git.GitCommandError
+        return self._git.GitCommandError
 
 
 def get_git_proxy(git_module: Optional[types.ModuleType]) -> _AbstractGitProxy:
-    return _GitProxy() if git_module else _DummyGitProxy()
+    return _GitProxy(git_module) if git_module else _DummyGitProxy()
 
 
 class GitProxyManager(_AbstractGitProxy):
     """We are using this manager for easy unit testing and mocking of the git module."""
 
     def __init__(self) -> None:
-        self._git_proxy = get_git_proxy(git)
+        self._git_proxy: Optional[_AbstractGitProxy] = None
+
+    def _get_git_proxy(self) -> _AbstractGitProxy:
+        if self._git_proxy is None:
+            self._git_proxy = get_git_proxy(_import_git())
+        return self._git_proxy
 
     def _set_dummy_git_proxy(self) -> None:
         self._git_proxy = _DummyGitProxy()
 
     def _set_git_proxy(self) -> None:
-        self._git_proxy = _GitProxy()
+        self._git_proxy = _GitProxy(_import_git())
 
     def get_repo(self, path: Optional['PathLike'] = None, *args, **kwargs) -> 'Repo':
-        return self._git_proxy.get_repo(path, *args, **kwargs)
+        return self._get_git_proxy().get_repo(path, *args, **kwargs)
 
     def get_null_tree(self) -> object:
-        return self._git_proxy.get_null_tree()
+        return self._get_git_proxy().get_null_tree()
 
     def get_invalid_git_repository_error(self) -> type[BaseException]:
-        return self._git_proxy.get_invalid_git_repository_error()
+        return self._get_git_proxy().get_invalid_git_repository_error()
 
     def get_git_command_error(self) -> type[BaseException]:
-        return self._git_proxy.get_git_command_error()
+        return self._get_git_proxy().get_git_command_error()
 
 
 git_proxy = GitProxyManager()

cycode/cyclient/ai_security_manager_client.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional
 from cycode.cli.exceptions.custom_exceptions import HttpUnauthorizedError
 from cycode.cyclient.cycode_client_base import CycodeClientBase
 from cycode.cyclient.logger import logger
+from cycode.cyclient.models import SessionContextResponse, SessionContextResponseSchema
 
 if TYPE_CHECKING:
     from cycode.cli.apps.ai_guardrails.scan.payload import AIHookPayload
@@ -114,8 +115,8 @@ class AISecurityManagerClient:
         enabled_plugins: Optional[dict] = None,
         skill_files: Optional[list[dict]] = None,
         user_email: Optional[str] = None,
-    ) -> bool:
-        """Report session context to the backend. Returns whether the report was accepted."""
+    ) -> Optional[SessionContextResponse]:
+        """Report session context to the backend. Returns None when the report was not accepted."""
         body: dict = {
             'hostname': hostname,
             'platform_name': platform_name,
@@ -129,9 +130,14 @@ class AISecurityManagerClient:
         }
 
         try:
-            self.client.post(self._build_endpoint_path(self._SESSION_CONTEXT_PATH), body=body)
-            return True
+            response = self.client.post(self._build_endpoint_path(self._SESSION_CONTEXT_PATH), body=body)
         except Exception as e:
             logger.debug('Failed to report session context', exc_info=e)
             # Don't fail the session if reporting fails
-            return False
+            return None
+
+        try:
+            return SessionContextResponseSchema().load(response.json())
+        except Exception as e:
+            logger.debug('Failed to parse the session context response', exc_info=e)
+            return SessionContextResponse()

cycode/cyclient/models.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Optional
 
-from marshmallow import EXCLUDE, Schema, fields, post_load
+from marshmallow import EXCLUDE, Schema, fields, missing, post_load
 
 
 class Detection(Schema):
@@ -578,3 +579,60 @@ class ScanConfigurationSchema(Schema):
     @post_load
     def build_dto(self, data: dict[str, Any], **_) -> 'ScanConfiguration':
         return ScanConfiguration(**data)
+
+
+class McpServerAuthorizationStatus(str, Enum):
+    AUTHORIZED = 'Authorized'
+    UNREVIEWED = 'Unreviewed'
+    UNAUTHORIZED = 'Unauthorized'
+
+    @classmethod
+    def parse(cls, raw_status: object) -> 'McpServerAuthorizationStatus':
+        """An unknown status reads as Unreviewed: no decision was made on the server."""
+        lowered = str(raw_status or '').lower()
+        return next((status for status in cls if status.value.lower() == lowered), cls.UNREVIEWED)
+
+
+class McpServerAuthorizationStatusField(fields.Field):
+    def _serialize(self, value: Optional[McpServerAuthorizationStatus], *_, **__) -> Optional[str]:
+        return value.value if value is not None else None
+
+    def deserialize(self, value: object, *_, **__) -> McpServerAuthorizationStatus:
+        return McpServerAuthorizationStatus.parse(None if value is missing else value)
+
+
+@dataclass
+class McpServerStatus:
+    alias: Optional[str] = None
+    normalized_id: Optional[str] = None
+    status: McpServerAuthorizationStatus = McpServerAuthorizationStatus.UNREVIEWED
+
+
+class McpServerStatusSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    alias = fields.String(allow_none=True, load_default=None)
+    normalized_id = fields.String(allow_none=True, load_default=None)
+    status = McpServerAuthorizationStatusField()
+
+    @post_load
+    def build_dto(self, data: dict[str, Any], **_) -> McpServerStatus:
+        return McpServerStatus(**data)
+
+
+@dataclass
+class SessionContextResponse:
+    # None when the response carries no (or malformed) MCP server statuses.
+    mcp_servers: Optional[list[McpServerStatus]] = None
+
+
+class SessionContextResponseSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    mcp_servers = fields.List(fields.Nested(McpServerStatusSchema), allow_none=True, load_default=None)
+
+    @post_load
+    def build_dto(self, data: dict[str, Any], **_) -> SessionContextResponse:
+        return SessionContextResponse(**data)

{cycode-3.25.1.dev5.dist-info → cycode-3.25.2.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cycode
-Version: 3.25.1.dev5
+Version: 3.25.2.dev1
 Summary: Boost security in your dev lifecycle via SAST, SCA, Secrets & IaC scanning.
 License-Expression: MIT
 License-File: LICENCE

{cycode-3.25.1.dev5.dist-info → cycode-3.25.2.dev1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cycode/__init__.py,sha256=6WKcMLjP5XCkzdZKqwYz8GeKUDhC-Ytqa32ZzGrlzBY,396
+cycode/__init__.py,sha256=DoaTBfeYc_ypdzVwGnWIXrteh9HwF94hYZUf03QS72M,396
 cycode/__main__.py,sha256=Z3bD5yrA7yPvAChcADQrqCaZd0ChGI1gdiwALwbWJ6U,104
 cycode/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cycode/cli/app.py,sha256=AlR2durAEbsa47PDfIj7JtMvJDWA_Dq6wPtVuMJYSCs,10250
@@ -8,26 +8,27 @@ cycode/cli/apps/ai_guardrails/__init__.py,sha256=NsqB1Ca83BIjJMcDSt6suec6Ed0iNna
 cycode/cli/apps/ai_guardrails/command_utils.py,sha256=NVwd0-2RGRKIqhsQ-4LNDR1D0gVm_o7n-z5LxG2bqAo,800
 cycode/cli/apps/ai_guardrails/consts.py,sha256=CO3j7CiVoc0CuWtIjYEWmGSXNAd2DfiPhffW-gZMRT4,1152
 cycode/cli/apps/ai_guardrails/hooks_manager.py,sha256=gIP4LGyOL1OFmCfxM1nrjedrBpCwLc_mcb7k40bIz_Q,9398
-cycode/cli/apps/ai_guardrails/ides/__init__.py,sha256=5odqWNfvvbFfAtR8ioEytXZ5VczWAOGyr1xuASC_OnQ,3346
-cycode/cli/apps/ai_guardrails/ides/_plugin_utils.py,sha256=XPIc9pZFEgdGVTSSAl9yqI48F88GKlFnJ5FsLUhHjCE,3981
+cycode/cli/apps/ai_guardrails/ides/__init__.py,sha256=wUvkI0b0RvoLNaQcEjX3v4YgAzz8gKmUxpIkjvWlWIE,3240
+cycode/cli/apps/ai_guardrails/ides/_plugin_utils.py,sha256=ieho3uuo0ddExiVVyEPT3Pu6ZGyw4FAePFusJnPUu3w,4013
 cycode/cli/apps/ai_guardrails/ides/_skill_utils.py,sha256=Xk8z-uquTMvg4JxNwZxnclR79ME7ZKq7rxht3aFQUeo,3972
-cycode/cli/apps/ai_guardrails/ides/base.py,sha256=B_wrSO48Hl__Xk92X4rKmwnY0RkP8jAJtE84wIW-Qnk,7985
-cycode/cli/apps/ai_guardrails/ides/claude_code.py,sha256=JCSB2PRPtZETFSskxV02hUwNRKExx7mXxtEmdxt_ruE,15707
-cycode/cli/apps/ai_guardrails/ides/codex.py,sha256=6MsjPaNlYkho0y8cYOUX9_9kH0Ow9drQ4q0ahfWNyoc,12252
-cycode/cli/apps/ai_guardrails/ides/copilot.py,sha256=XK2CLdB3oLJrP5Z-pGNsLbnwfehv4AW4vTLdvSE3eb0,21894
-cycode/cli/apps/ai_guardrails/ides/cursor.py,sha256=cqi12ELV5ZF7ANUA9n33gc8Hj9hURqEBLJ3gzf-v68w,5850
+cycode/cli/apps/ai_guardrails/ides/base.py,sha256=fMfcOtqfs3KM1oD54ePS--YaWfk3YuCXtRn8IpAfhEk,7962
+cycode/cli/apps/ai_guardrails/ides/claude_code.py,sha256=7oEhrbu2XatqBylR_xrJQPStU8v1lfFKeT00lximnFM,17354
+cycode/cli/apps/ai_guardrails/ides/codex.py,sha256=IdSVDClifhHQZLKxM4mFbUkn8j2dh2fT5PNoISTwu-s,13729
+cycode/cli/apps/ai_guardrails/ides/copilot.py,sha256=AWYQM9ulmyV5o_RyzfK4nkjCxF724F0bi1RhfXTgunY,21892
+cycode/cli/apps/ai_guardrails/ides/cursor.py,sha256=b8VusI2pxG3GKkkS2y84zr4xiMqz-1UBe-8NLFVMjIA,7419
 cycode/cli/apps/ai_guardrails/install_command.py,sha256=3T-Wj_Fr871uhfTe77CGqrkeAwvHafK_aEv7BZ0jAJU,4069
 cycode/cli/apps/ai_guardrails/scan/__init__.py,sha256=qJc82XiQGiAuc1sYY8Ij_A-qXpxgLPuayQq8xWlouMA,48
 cycode/cli/apps/ai_guardrails/scan/consts.py,sha256=8H8JXlgm65sYkgTXqsBInHhHe80UPjqY4vumZXB4GGM,1060
 cycode/cli/apps/ai_guardrails/scan/detach.py,sha256=8BRgBq9Qi8nXEx6NKlE8scSRPkO30XCfsiI5PLvq6Gk,2700
-cycode/cli/apps/ai_guardrails/scan/guardrail_config.py,sha256=KHYZCiF86zpuUScex46oQ8dsA5zu30WmCXU54O6Pphg,6871
-cycode/cli/apps/ai_guardrails/scan/handlers.py,sha256=pHs_T6uTAT4QlJ_MMhc-EdjdfH9IdVczZ6XMdmaWPKg,17760
+cycode/cli/apps/ai_guardrails/scan/guardrail_config.py,sha256=Cm-a52lGIRn7u5utHNOak42wX5_EK9Du4JVuS-kNhMU,7970
+cycode/cli/apps/ai_guardrails/scan/handlers.py,sha256=utVeDKLKzE0DtvMysipTRYS-3J_SqVlaxwY39yZS-_M,20527
+cycode/cli/apps/ai_guardrails/scan/mcp_server_status.py,sha256=BrxS6YSvdpp8fappgR_PY96lex1kMqG68bgI5n0D-E8,3895
 cycode/cli/apps/ai_guardrails/scan/payload.py,sha256=sWsWq5yXP54MVCajsb180kLuprI_M2kspMOzQGh7r_o,1534
 cycode/cli/apps/ai_guardrails/scan/policy.py,sha256=3HuDoL_NYE3lyHRAlIMleq6pi-stIDQwotHsKhUFhTQ,5000
 cycode/cli/apps/ai_guardrails/scan/scan_command.py,sha256=fgV32phgkBPwqSau7oFDISZ58CVpq214JlYwZQM9bnM,8318
-cycode/cli/apps/ai_guardrails/scan/types.py,sha256=ybQm242QN0l_4SSNX4xMHXxzqEK-MW-hfIOixI7zvGU,1497
+cycode/cli/apps/ai_guardrails/scan/types.py,sha256=6nh_40KSTuWabsaVqkZEl712m6lAI8k9OuhPo8KhJdw,1553
 cycode/cli/apps/ai_guardrails/scan/utils.py,sha256=4CIZAILS9m5-JsFbUderwBVzFAjqAVVVRhWgE9oLPhM,5292
-cycode/cli/apps/ai_guardrails/session_start_command.py,sha256=oEW-OsHXkf8P7SX1vKa9Ddlv_hASRiQ42JZR3MnJfRg,7171
+cycode/cli/apps/ai_guardrails/session_start_command.py,sha256=BohIVr7d1VmesxKEC0vUOp_xuTa5DJIPmu4EEW5aFHU,8267
 cycode/cli/apps/ai_guardrails/status_command.py,sha256=Uqss68TEPCYPXpLix6Bh-4J3g-khxWsAqlIGYH5x4bQ,3203
 cycode/cli/apps/ai_guardrails/uninstall_command.py,sha256=dOmePfZmlHAPy2zEJM1yMtSuDqvzDwtqgmLKYK-T9PI,2698
 cycode/cli/apps/ai_remediation/__init__.py,sha256=8vYthY9RQeJqEni3AIF5sryz8n-XJQ6VNqG4aEFBAdY,553
@@ -185,7 +186,7 @@ cycode/cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 cycode/cli/utils/binary_utils.py,sha256=PxP-rVJ1lEiOam-DQ1XU68oWtfwup4sCFHXv54cfZkY,2528
 cycode/cli/utils/enum_utils.py,sha256=h_VTCfJ-0hnhwDsEznmx56rJrCb5FQ8u6PrI6p8MP3E,187
 cycode/cli/utils/get_api_client.py,sha256=wwHabfVCDbFjcIwOn5Raho8MEPiOAgkHlGUEfXKpl8U,3542
-cycode/cli/utils/git_proxy.py,sha256=FPHMBiyLFK9X9vKYpKySRKJH6Dc9Cb3nO241Q95dASE,2911
+cycode/cli/utils/git_proxy.py,sha256=S_CwJxBOBO1lvp5Eoh_-vMFIxiFU2YZ_BhpQCufI54A,3486
 cycode/cli/utils/host_info.py,sha256=Clln3qCJR00rw6HndD0bAIv329n_bOEx42TKW6FqXFQ,6379
 cycode/cli/utils/ignore_utils.py,sha256=cODqhnOHA2kRo8rMY0YcmcKkmXNPOC9UTCmFu62RRqE,15567
 cycode/cli/utils/jwt_utils.py,sha256=EGI-0CKhCGY8hIcZ9b9diq9hqtOUf8Ha8ukeVJIf974,818
@@ -202,7 +203,7 @@ cycode/cli/utils/version_checker.py,sha256=0f5PaTk02ZkDxzBqZOeMV9mU_CWcx6HKW80jU
 cycode/cli/utils/yaml_utils.py,sha256=eyOcfNtqvmRMKrKY5jCdwwKKOsXAFchcBAoES0F_o7c,2167
 cycode/config.py,sha256=jHORGZQcAXkAGSf2XreC-RQoc8sdNWja69QKtPWTbWo,1044
 cycode/cyclient/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cycode/cyclient/ai_security_manager_client.py,sha256=90fvqH_h2-dI9YqQ6oo4YBfa777p5mSr8JSM1ZZJJcE,5486
+cycode/cyclient/ai_security_manager_client.py,sha256=MidcAzMtAJdOJtpgRsotJNQUOmRqTdgs4_A4_poNB6A,5840
 cycode/cyclient/ai_security_manager_service_config.py,sha256=83pQzgOb93JW6E-dznJkI4c0NEXmQRlx9YZKMmjVwp8,808
 cycode/cyclient/auth_client.py,sha256=TwbmZ358Ancf-Q-IZolvfljZ8691_6botsqd0R0PLPk,2105
 cycode/cyclient/base_token_auth_client.py,sha256=V907nf_1TvtfzwDal2bAgmXvgqaaX_ERUvSRipujz30,5490
@@ -218,13 +219,13 @@ cycode/cyclient/cycode_token_based_client.py,sha256=frbrv1jzF388SXqHNNkZ95Hbx7Vj
 cycode/cyclient/headers.py,sha256=NMlVH9hAxZ-CyWaZJio29Mc5KFcFvNvnJTshueM3hFI,1337
 cycode/cyclient/import_sbom_client.py,sha256=M0RAn2dDh9woI3SUkgSHCQxhbARoLpyAM3amOausz8E,2749
 cycode/cyclient/logger.py,sha256=oTkay7QzoOIVQ71cGOy4ukkijYGA3IKJlHkL24Px5ds,70
-cycode/cyclient/models.py,sha256=Bv3K10KmUlF_VG81GGMeyFbJWOR3sQZh6j-EDdeeKK4,15661
+cycode/cyclient/models.py,sha256=KyazUWcdMW3LCEplIoObKHngJNT-HH26xGCqLalNBTI,17638
 cycode/cyclient/report_client.py,sha256=Scq30NeJPzgXv0hPLO1U05AdE9i_2iu6cIrSKpEJ-cM,4399
 cycode/cyclient/scan_client.py,sha256=DqAZ7u6Z_cvw9A9RlLkAQUgLRwPCCAsUq5U9umt4F7Y,16955
 cycode/cyclient/scan_config_base.py,sha256=mXsPZGYCtp85rv5GIige40yQZXuRcEKUW-VQJ0vgFzk,1201
 cycode/logger.py,sha256=EfZGRK6VC5rE_LAjIcRrHFiQCueylCDXoG6bvGkrIME,2111
-cycode-3.25.1.dev5.dist-info/METADATA,sha256=NdMkWG7AUN3Z3cckV3wmSsHHYlPCU5GnT1pEeT1iO00,96824
-cycode-3.25.1.dev5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cycode-3.25.1.dev5.dist-info/entry_points.txt,sha256=iDcVJM8ByLElVgvBgtYxDjw1kT7O8Mo0LcWZIT5L3Ig,45
-cycode-3.25.1.dev5.dist-info/licenses/LICENCE,sha256=2Wx4N6mD_4xB7-E3hPkZ3MPhpJy__k_I8MaCSO-PDRo,1068
-cycode-3.25.1.dev5.dist-info/RECORD,,
+cycode-3.25.2.dev1.dist-info/METADATA,sha256=8MDn9Sw-Mjdx7tfPV3uDI7O9vR23_eKj4R1WQz2utW0,96824
+cycode-3.25.2.dev1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cycode-3.25.2.dev1.dist-info/entry_points.txt,sha256=iDcVJM8ByLElVgvBgtYxDjw1kT7O8Mo0LcWZIT5L3Ig,45
+cycode-3.25.2.dev1.dist-info/licenses/LICENCE,sha256=2Wx4N6mD_4xB7-E3hPkZ3MPhpJy__k_I8MaCSO-PDRo,1068
+cycode-3.25.2.dev1.dist-info/RECORD,,