feat: mcp activity history for Copilot

Author: pbeslin-gg

ggshield/verticals/ai/agents/copilot.py

@@ -1,6 +1,8 @@
+import logging
 import re
+from datetime import datetime
 from pathlib import Path
-from typing import Dict, Iterator, Optional, Tuple
+from typing import Any, Dict, Iterator, Optional, Tuple
 
 from ggshield.core.dirs import get_user_home_dir
 from ggshield.verticals.ai.models import (
@@ -17,6 +19,9 @@
 from .vscode import VSCode
 
 
+logger = logging.getLogger(__name__)
+
+
 class Copilot(VSCode):
     """Behavior specific to Copilot CLI.
 
@@ -119,7 +124,76 @@ def _lookup_server_name(
     def iter_history_events(
         self, ai_config: Optional[AIDiscovery]
     ) -> Iterator[MCPActivityRequest]:
-        return iter(())
+        """Walk every Copilot CLI session and yield MCP tool calls.
+
+        Sessions live under ``~/.copilot/session-state/<uuid>/events.jsonl``.
+        """
+        history_root = get_user_home_dir() / ".copilot" / "session-state"
+        for session_dir in sorted(history_root.glob("*")):
+            events_path = session_dir / "events.jsonl"
+            if not events_path.is_file():
+                continue
+            yield from self._parse_events_file(events_path, ai_config)
+
+    def _parse_events_file(
+        self, path: Path, ai_config: Optional[AIDiscovery]
+    ) -> Iterator[MCPActivityRequest]:
+        """Yield MCP events from a single Copilot CLI events file."""
+        cwd = ""
+        for line in self._load_jsonl_file(path):
+            if not isinstance(line, dict):
+                continue
+            event_type = line.get("type")
+            data = line.get("data") or {}
+            if event_type == "session.start":
+                folder = (data.get("context") or {}).get("cwd")
+                if isinstance(folder, str):
+                    cwd = folder
+                continue
+            if event_type != "tool.execution_start":
+                continue
+            event = self._build_event(line, data, cwd, ai_config)
+            if event is not None:
+                yield event
+
+    def _build_event(
+        self,
+        line: Dict[str, Any],
+        data: Dict[str, Any],
+        cwd: str,
+        ai_config: Optional[AIDiscovery],
+    ) -> Optional[MCPActivityRequest]:
+        server_cfg_name = data.get("mcpServerName") or ""
+        tool_name = data.get("mcpToolName") or ""
+        if not server_cfg_name or not tool_name:
+            return None
+        timestamp = _parse_iso_timestamp(line.get("timestamp"))
+        if timestamp is None:
+            return None
+        arguments = data.get("arguments")
+        if not isinstance(arguments, dict):
+            arguments = {}
+        return MCPActivityRequest(
+            user=self._user_or_default(ai_config),
+            tool=tool_name,
+            server=self._resolve_server_name(server_cfg_name, ai_config),
+            agent=self.name,
+            model="",
+            cwd=cwd,
+            input=arguments,
+            timestamp=timestamp,
+            idempotency_key=data.get("toolCallId") or "",
+        )
+
+
+def _parse_iso_timestamp(raw: Any) -> Optional[datetime]:
+    """Parse an ISO-8601 timestamp string, tolerating a trailing ``Z``."""
+    if not isinstance(raw, str):
+        return None
+    try:
+        return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError:
+        return None
 
 
 def _mangle_name(name: str) -> str:

tests/unit/verticals/ai/test_copilot_history.py

@@ -0,0 +1,229 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from pygitguardian.models import AIDiscovery, MCPConfiguration, MCPServer, UserInfo
+
+from ggshield.verticals.ai.agents.copilot import Copilot
+
+
+def _session_start(cwd: str = "/repo", session_id: str = "sess-1") -> str:
+    return json.dumps(
+        {
+            "type": "session.start",
+            "data": {
+                "sessionId": session_id,
+                "context": {"cwd": cwd},
+            },
+            "id": "evt-start",
+            "timestamp": "2026-05-18T14:09:37.678Z",
+        }
+    )
+
+
+def _tool_execution_start(
+    tool_call_id: str = "call-1",
+    mcp_server_name: str = "github-mcp-server",
+    mcp_tool_name: str = "get_file_contents",
+    arguments=None,
+    timestamp: str = "2026-05-18T14:10:46.052Z",
+) -> str:
+    data: dict = {
+        "toolCallId": tool_call_id,
+        "toolName": f"{mcp_server_name}-{mcp_tool_name}",
+        "arguments": arguments if arguments is not None else {"owner": "GitGuardian"},
+        "turnId": "0",
+    }
+    if mcp_server_name:
+        data["mcpServerName"] = mcp_server_name
+    if mcp_tool_name:
+        data["mcpToolName"] = mcp_tool_name
+    return json.dumps(
+        {
+            "type": "tool.execution_start",
+            "data": data,
+            "id": f"evt-{tool_call_id}",
+            "timestamp": timestamp,
+        }
+    )
+
+
+def _seed_session(tmp_path: Path, lines: list, session_id: str = "sess-1") -> Path:
+    session_dir = tmp_path / ".copilot" / "session-state" / session_id
+    session_dir.mkdir(parents=True)
+    events = session_dir / "events.jsonl"
+    events.write_text("\n".join(lines) + "\n")
+    return events
+
+
+@pytest.fixture
+def empty_ai_config() -> AIDiscovery:
+    return AIDiscovery(
+        user=UserInfo(hostname="h", username="u", machine_id="m"),
+        servers=[],
+        discovery_duration=0.0,
+    )
+
+
+class TestCopilotIterHistoryEvents:
+    def test_extracts_mcp_call(self, tmp_path: Path, empty_ai_config) -> None:
+        _seed_session(
+            tmp_path,
+            [
+                _session_start(cwd="/repo"),
+                _tool_execution_start(
+                    tool_call_id="call_abc",
+                    mcp_server_name="github-mcp-server",
+                    mcp_tool_name="get_file_contents",
+                    arguments={"owner": "GitGuardian", "repo": "ggshield"},
+                    timestamp="2026-05-18T14:10:46.052Z",
+                ),
+            ],
+        )
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert len(events) == 1
+        ev = events[0]
+        assert ev.tool == "get_file_contents"
+        assert ev.server == "github-mcp-server"
+        assert ev.agent == "copilot"
+        assert ev.cwd == "/repo"
+        assert ev.idempotency_key == "call_abc"
+        assert ev.timestamp == datetime(
+            2026, 5, 18, 14, 10, 46, 52000, tzinfo=timezone.utc
+        )
+        assert ev.input == {"owner": "GitGuardian", "repo": "ggshield"}
+
+    def test_skips_non_mcp_tool_calls(self, tmp_path: Path, empty_ai_config) -> None:
+        """``tool.execution_start`` events without ``mcpServerName`` are not MCP calls."""
+        builtin = json.dumps(
+            {
+                "type": "tool.execution_start",
+                "data": {
+                    "toolCallId": "call_builtin",
+                    "toolName": "report_intent",
+                    "arguments": {"intent": "Searching"},
+                    "turnId": "0",
+                },
+                "id": "evt-builtin",
+                "timestamp": "2026-05-18T14:10:46.052Z",
+            }
+        )
+        _seed_session(tmp_path, [_session_start(), builtin])
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert events == []
+
+    def test_drops_event_with_unparseable_timestamp(
+        self, tmp_path: Path, empty_ai_config
+    ) -> None:
+        _seed_session(
+            tmp_path,
+            [
+                _session_start(),
+                _tool_execution_start(timestamp="not-a-date"),
+            ],
+        )
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert events == []
+
+    def test_resolves_server_name_via_configuration(self, tmp_path: Path) -> None:
+        """``mcpServerName`` matches ``MCPConfiguration.name`` byte-for-byte."""
+        _seed_session(
+            tmp_path,
+            [
+                _session_start(),
+                _tool_execution_start(mcp_server_name="github-mcp-server"),
+            ],
+        )
+
+        config = AIDiscovery(
+            user=UserInfo(hostname="h", username="u", machine_id="m"),
+            servers=[
+                MCPServer(
+                    name="GitHub",
+                    configurations=[
+                        MCPConfiguration(
+                            name="github-mcp-server",
+                            agent="copilot",
+                            scope=MCPConfiguration.Scope.USER,
+                            transport=MCPConfiguration.Transport.STDIO,
+                            project=None,
+                        )
+                    ],
+                )
+            ],
+            discovery_duration=0.0,
+        )
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(config))
+
+        assert events[0].server == "GitHub"
+
+    def test_walks_multiple_sessions(self, tmp_path: Path, empty_ai_config) -> None:
+        _seed_session(
+            tmp_path,
+            [_session_start(cwd="/repo-a"), _tool_execution_start(tool_call_id="a")],
+            session_id="sess-a",
+        )
+        _seed_session(
+            tmp_path,
+            [_session_start(cwd="/repo-b"), _tool_execution_start(tool_call_id="b")],
+            session_id="sess-b",
+        )
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert {ev.idempotency_key for ev in events} == {"a", "b"}
+        assert {ev.cwd for ev in events} == {"/repo-a", "/repo-b"}
+
+    def test_missing_history_root_yields_nothing(
+        self, tmp_path: Path, empty_ai_config
+    ) -> None:
+        """A user who has never run Copilot CLI has no ``~/.copilot/session-state``."""
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert events == []
+
+    def test_session_without_events_file_is_skipped(
+        self, tmp_path: Path, empty_ai_config
+    ) -> None:
+        (tmp_path / ".copilot" / "session-state" / "empty").mkdir(parents=True)
+
+        with patch(
+            "ggshield.verticals.ai.agents.copilot.get_user_home_dir",
+            return_value=tmp_path,
+        ):
+            events = list(Copilot().iter_history_events(empty_ai_config))
+
+        assert events == []

tests/unit/verticals/ai/test_vscode_history.py

@@ -78,34 +78,6 @@ def test_skips_internal_tools(self) -> None:
         assert list(_find_mcp_invocations(obj)) == []
 
 
-class TestCopilotIterHistoryEvents:
-    """Copilot CLI sessions are not in workspaceStorage — the parser must not pick them up."""
-
-    def test_returns_empty(self, tmp_path: Path, empty_ai_config) -> None:
-        from ggshield.verticals.ai.agents.copilot import Copilot
-
-        # Even with VSCode-shaped data on disk, the Copilot CLI agent should yield nothing.
-        workspace_hash = (
-            tmp_path / ".config" / "Code" / "User" / "workspaceStorage" / "ws1"
-        )
-        sessions = workspace_hash / "chatSessions"
-        sessions.mkdir(parents=True)
-        (workspace_hash / "workspace.json").write_text(
-            json.dumps({"folder": "file:///repo"})
-        )
-        (sessions / "session.jsonl").write_text(
-            _request_line(1_778_855_521_780, [_invocation("call-1")]) + "\n"
-        )
-
-        with patch(
-            "ggshield.verticals.ai.agents.vscode.get_user_home_dir",
-            return_value=tmp_path,
-        ):
-            events = list(Copilot().iter_history_events(empty_ai_config))
-
-        assert events == []
-
-
 class TestVSCodeIterHistoryEvents:
     def _seed_session(
         self, tmp_path: Path, lines: list[str], workspace_folder: str