agent-shell-py 0.2.4__tar.gz → 0.2.5__tar.gz

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/AGENTS.md

@@ -171,9 +171,19 @@ All adapters write to user-scope configuration:
 | OpenCode | direct JSON file write | `~/.config/opencode/opencode.json` |
 | Copilot CLI | direct JSON file write | `~/.copilot/mcp-config.json` |
 | Codex | `codex mcp add` subprocess | Codex config |
+| Cursor | direct JSON file write | `~/.cursor/mcp.json` |
 | Grok | `grok mcp add --scope user` subprocess | `~/.grok/config.toml` (managed by CLI) |
 
-Adds are idempotent (overwrite existing entries with the same name). Removes warn rather than raise when the named server is not found. Claude Code listing reads the user-scope `mcpServers` entries from `~/.claude.json` directly, avoiding the health checks and human-readable output of `claude mcp list`. Grok listing reads user-scope `mcp_servers` entries from `~/.grok/config.toml` directly for the same reason. MCP is not implemented for Pi or Cursor — all three methods raise `NotImplementedError`. Pi manages capability via `pi install` extensions (which needs investigation before wiring up); Cursor's `mcp` subcommands are login/list/list-tools/enable/disable only (no add/remove — servers are declared in `.cursor/mcp.json`), and `mcp list` reports only `name: status`, not the transport an `MCPServerSpec` needs.
+Adds are idempotent (update existing entries with the same name). Cursor preserves native fields
+that `MCPServerSpec` cannot represent when an update keeps the same transport, and writes its file
+atomically with user-only permissions. Removes warn rather than raise when the named server is not
+found. Claude Code listing reads the user-scope `mcpServers`
+entries from `~/.claude.json` directly, avoiding the health checks and human-readable output of
+`claude mcp list`. Cursor manages user-scope MCP entries directly in `~/.cursor/mcp.json` because
+its `mcp` subcommands have no add/remove commands. Grok listing reads user-scope `mcp_servers`
+entries from `~/.grok/config.toml` directly for the same reason. Pi's MCP add/remove/list methods
+raise `NotImplementedError`. Pi manages capability via `pi install` extensions, which needs
+investigation before wiring up.
 
 ## Test Philosophy
 

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-shell-py
-Version: 0.2.4
+Version: 0.2.5
 Summary: A lightweight abstraction for executing CLI coding agents headlessly
 License-Expression: MIT
 License-File: LICENSE
@@ -276,8 +276,9 @@ print(f"Session: {response.session_id}")
 > tools are auto-*rejected* but the run still completes. `allowed_tools`, `effort`, and
 > `disallowed_tools` are **ignored** — Cursor exposes no per-call tool policy or effort flag
 > (tool policy lives in `.cursor/cli.json`), so each emits a `UserWarning`. On a Free plan
-> only `model=None`/`"auto"` works. MCP servers are declared in `.cursor/mcp.json`; the
-> `add`/`remove`/`list` MCP methods raise `NotImplementedError`.
+> only `model=None`/`"auto"` works. MCP add/remove/list are supported by directly managing
+> the user-scope `~/.cursor/mcp.json` file because `cursor-agent mcp` has no add/remove
+> subcommands.
 
 ### Grok
 
@@ -348,7 +349,14 @@ await shell.add_mcp_server(MCPServerSpec(
 ))
 ```
 
-`add_mcp_server` overwrites an existing server with the same name. `remove_mcp_server` warns rather than raises when the named server is not found. `list_mcp_servers()` works for Claude Code, OpenCode, Copilot CLI, Codex, and Grok. Claude Code reads user-scope entries directly from `~/.claude.json`, and Grok from `~/.grok/config.toml`, so listing does not launch configured servers for health checks. MCP is not supported for Pi or Cursor — neither CLI exposes an add/remove subcommand, so all three MCP methods raise `NotImplementedError`.
+`add_mcp_server` adds or updates a server with the same name. Cursor preserves native fields
+that `MCPServerSpec` cannot represent when an update keeps the same transport. The configuration
+is written atomically with user-only permissions. `remove_mcp_server` warns rather than raises
+when the named server is not found. `list_mcp_servers()` works for
+Claude Code, OpenCode, Copilot CLI, Codex, Cursor, and Grok. Claude Code reads user-scope
+entries directly from `~/.claude.json`, Cursor from `~/.cursor/mcp.json`, and Grok from
+`~/.grok/config.toml`, so listing does not launch configured servers for health checks. MCP
+is not supported for Pi; all three MCP methods raise `NotImplementedError`.
 
 ## Logging
 

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/README.md

@@ -267,8 +267,9 @@ print(f"Session: {response.session_id}")
 > tools are auto-*rejected* but the run still completes. `allowed_tools`, `effort`, and
 > `disallowed_tools` are **ignored** — Cursor exposes no per-call tool policy or effort flag
 > (tool policy lives in `.cursor/cli.json`), so each emits a `UserWarning`. On a Free plan
-> only `model=None`/`"auto"` works. MCP servers are declared in `.cursor/mcp.json`; the
-> `add`/`remove`/`list` MCP methods raise `NotImplementedError`.
+> only `model=None`/`"auto"` works. MCP add/remove/list are supported by directly managing
+> the user-scope `~/.cursor/mcp.json` file because `cursor-agent mcp` has no add/remove
+> subcommands.
 
 ### Grok
 
@@ -339,7 +340,14 @@ await shell.add_mcp_server(MCPServerSpec(
 ))
 ```
 
-`add_mcp_server` overwrites an existing server with the same name. `remove_mcp_server` warns rather than raises when the named server is not found. `list_mcp_servers()` works for Claude Code, OpenCode, Copilot CLI, Codex, and Grok. Claude Code reads user-scope entries directly from `~/.claude.json`, and Grok from `~/.grok/config.toml`, so listing does not launch configured servers for health checks. MCP is not supported for Pi or Cursor — neither CLI exposes an add/remove subcommand, so all three MCP methods raise `NotImplementedError`.
+`add_mcp_server` adds or updates a server with the same name. Cursor preserves native fields
+that `MCPServerSpec` cannot represent when an update keeps the same transport. The configuration
+is written atomically with user-only permissions. `remove_mcp_server` warns rather than raises
+when the named server is not found. `list_mcp_servers()` works for
+Claude Code, OpenCode, Copilot CLI, Codex, Cursor, and Grok. Claude Code reads user-scope
+entries directly from `~/.claude.json`, Cursor from `~/.cursor/mcp.json`, and Grok from
+`~/.grok/config.toml`, so listing does not launch configured servers for health checks. MCP
+is not supported for Pi; all three MCP methods raise `NotImplementedError`.
 
 ## Logging
 

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/docs/development/agent_parameter_comparison.md

@@ -128,9 +128,9 @@ test checks all seven real discovery commands.
 - **Headless mode**: `-p` / `--prompt` for one-shot; `--acp` for Agent Client Protocol
 - **Model**: `--model <model>`; use `auto` to let Copilot choose
 - **Effort**: `--effort` / `--reasoning-effort` with choices
-  `none|minimal|low|medium|high|xhigh|max`. AgentShell accepts effort values
-  case-insensitively, validates them against these choices, and passes the normalized lowercase
-  value to Copilot via `--effort`.
+  `none|minimal|low|medium|high|xhigh|max`. AgentShell treats `None` and `""` as omitted, so
+  Copilot uses its default. Explicit values, including `"none"`, are accepted case-insensitively,
+  validated against these choices, and passed to Copilot via `--effort` in lowercase.
 - **Allowed tools**: `--allow-tool`, `--deny-tool`, `--available-tools`,
   `--excluded-tools`, `--allow-all-tools`
 - **Auto-approve**: `--allow-all-tools`; `--allow-all` / `--yolo` also grant path and URL
@@ -193,10 +193,10 @@ test checks all seven real discovery commands.
   cursor-agent ACCEPTS an unknown id — `--resume=<never-seen-uuid>` starts a session under that
   id and echoes it back rather than failing, so id identity proves the flag was passed through
   and honoured, not that a prior transcript was replayed (measured 2026-07-26)
-- **MCP**: `cursor-agent mcp` = login/list/list-tools/enable/disable only (no add/remove);
-  servers declared in `.cursor/mcp.json`. All three adapter MCP methods raise
-  `NotImplementedError` — including `list_mcp_servers`, because `mcp list` emits only
-  `name: status` and cannot rebuild an `MCPServerSpec`
+- **MCP**: `cursor-agent mcp` = login/list/list-tools/enable/disable only (no add/remove).
+  The adapter manages user-scope servers directly in `~/.cursor/mcp.json`, which provides the
+  transport details that `mcp list` omits. Writes are atomic and user-only; same-transport
+  updates preserve Cursor-native fields that `MCPServerSpec` cannot represent.
 - **Usage**: the terminal `result` event carries `usage.outputTokens` (undocumented but real)
   and `duration_ms`; there is no cost field, so `cost` is `0.0`
 

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/skills/invoking-cli-agents/SKILL.md

@@ -316,7 +316,8 @@ succeeded = saw_ok and error is None         # absent result => succeeded stays
   **not** run your prompt, so use the stream-based check above when you care about a specific
   call's outcome.
 - **MCP server management** — `add_mcp_server`, `remove_mcp_server`, `list_mcp_servers` manage
-  the underlying CLI's MCP config (Pi and Cursor raise `NotImplementedError`).
+  user-scope MCP configuration. Pi raises `NotImplementedError`; Cursor is managed directly
+  through `~/.cursor/mcp.json` because `cursor-agent mcp` has no add/remove subcommands.
 
 See [api-reference.md](api-reference.md) for their full signatures and the `MCPServerSpec` model.
 

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/src/agent_shell/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.5'
+__version_tuple__ = version_tuple = (0, 2, 5)
 
 __commit_id__ = commit_id = None

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/src/agent_shell/adapters/copilot_cli_adapter.py

@@ -48,7 +48,7 @@ _COPILOT_EFFORTS = ("none", "minimal", "low", "medium", "high", "xhigh", "max")
 
 
 def _normalize_effort(effort: str | None) -> str | None:
-    if effort is None:
+    if effort is None or effort == "":
         return None
 
     normalized = effort.lower() if isinstance(effort, str) else None

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/src/agent_shell/adapters/cursor_adapter.py

@@ -4,12 +4,15 @@ import json
 import logging
 import os
 import warnings
+from pathlib import Path
+from tempfile import NamedTemporaryFile
 from typing import AsyncIterator
 
 from agent_shell.models.agent import (
     AgentResponse,
     HealthCheckResult,
     MCPServerSpec,
+    MCPServerType,
     StreamEvent,
 )
 from agent_shell.process_cleanup import (
@@ -324,15 +327,173 @@ class CursorAdapter:
             models.append(model.strip())
         return models
 
+    def _mcp_config_path(self) -> Path:
+        return Path(os.path.expanduser("~/.cursor/mcp.json"))
+
+    def _read_mcp_config(self) -> dict:
+        path = self._mcp_config_path()
+        if not path.exists():
+            return {}
+        return json.loads(path.read_text())
+
+    def _write_mcp_config(self, config: dict) -> None:
+        path = self._mcp_config_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary_path: Path | None = None
+
+        try:
+            with NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    dir=path.parent,
+                    prefix=f".{path.name}.",
+                    delete=False,
+            ) as temporary_file:
+                temporary_path = Path(temporary_file.name)
+                temporary_file.write(json.dumps(config, indent=2) + "\n")
+                temporary_file.flush()
+                os.fsync(temporary_file.fileno())
+
+            os.replace(temporary_path, path)
+            temporary_path = None
+        finally:
+            if temporary_path is not None:
+                temporary_path.unlink(missing_ok=True)
+
+    @staticmethod
+    def _mcp_servers(config: dict) -> dict:
+        if not isinstance(config, dict):
+            raise ValueError("Cursor mcp.json root must be a JSON object")
+
+        servers = config.get("mcpServers", {})
+        if not isinstance(servers, dict):
+            raise ValueError("Cursor 'mcpServers' must be a JSON object")
+
+        config["mcpServers"] = servers
+        return servers
+
+    @staticmethod
+    def _mcp_entry_type(entry: dict) -> MCPServerType | None:
+        entry_type = entry.get("type")
+        if entry_type == "stdio":
+            return MCPServerType.STDIO
+        if entry_type in {"http", "sse"}:
+            return MCPServerType.HTTP
+        if entry_type is not None:
+            return None
+        if entry.get("command"):
+            return MCPServerType.STDIO
+        if entry.get("url"):
+            return MCPServerType.HTTP
+        return None
+
+    @staticmethod
+    def _string_list(value: object, field_name: str) -> list[str]:
+        if value is None:
+            return []
+        if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+            raise TypeError(f"{field_name} must be a list of strings")
+        return list(value)
+
+    @staticmethod
+    def _string_mapping(value: object, field_name: str) -> dict[str, str]:
+        if value is None:
+            return {}
+        if not isinstance(value, dict) or not all(
+                isinstance(key, str) and isinstance(item, str)
+                for key, item in value.items()
+        ):
+            raise TypeError(f"{field_name} must be an object with string values")
+        return dict(value)
+
     async def add_mcp_server(self, mcp_server: MCPServerSpec) -> None:
-        # Cursor's `mcp` subcommands are login/list/list-tools/enable/disable ONLY — there is
-        # no add/remove. Servers are declared in .cursor/mcp.json, and `mcp list` reports only
-        # `name: status` (no transport/command/url), so an MCPServerSpec cannot be faithfully
-        # round-tripped either. Fail loud rather than silently no-op.
-        raise NotImplementedError("add_mcp_server is not supported for Cursor")
+        config = self._read_mcp_config()
+        servers = self._mcp_servers(config)
+
+        if mcp_server.type == MCPServerType.STDIO:
+            entry = {
+                "command": mcp_server.command,
+                "args": list(mcp_server.args),
+                "env": dict(mcp_server.env),
+            }
+        else:
+            entry = {
+                "url": mcp_server.url,
+                "headers": dict(mcp_server.headers),
+            }
+
+        existing = servers.get(mcp_server.name)
+        if (
+                isinstance(existing, dict)
+                and self._mcp_entry_type(existing) == mcp_server.type
+        ):
+            entry = {**existing, **entry}
+
+        servers[mcp_server.name] = entry
+        self._write_mcp_config(config)
 
     async def remove_mcp_server(self, mcp_server_name: str) -> None:
-        raise NotImplementedError("remove_mcp_server is not supported for Cursor")
+        config = self._read_mcp_config()
+        servers = self._mcp_servers(config)
+        if mcp_server_name not in servers:
+            warnings.warn(
+                f"MCP server '{mcp_server_name}' not found in Cursor config",
+                UserWarning,
+                stacklevel=2,
+            )
+            return
+
+        del servers[mcp_server_name]
+        self._write_mcp_config(config)
 
     async def list_mcp_servers(self) -> list[MCPServerSpec]:
-        raise NotImplementedError("list_mcp_servers is not supported for Cursor")
+        config = self._read_mcp_config()
+        try:
+            servers = self._mcp_servers(config)
+        except ValueError as error:
+            warnings.warn(str(error), UserWarning, stacklevel=2)
+            return []
+
+        result: list[MCPServerSpec] = []
+        for name, entry in servers.items():
+            if not isinstance(entry, dict):
+                warnings.warn(
+                    f"Skipping malformed MCP entry '{name}': expected object, "
+                    f"got {type(entry).__name__}",
+                    UserWarning,
+                    stacklevel=2,
+                )
+                continue
+
+            try:
+                entry_type = self._mcp_entry_type(entry)
+                if entry_type == MCPServerType.STDIO:
+                    result.append(MCPServerSpec(
+                        name=name,
+                        type=MCPServerType.STDIO,
+                        command=entry.get("command"),
+                        args=self._string_list(entry.get("args"), "args"),
+                        env=self._string_mapping(entry.get("env"), "env"),
+                    ))
+                elif entry_type == MCPServerType.HTTP:
+                    result.append(MCPServerSpec(
+                        name=name,
+                        type=MCPServerType.HTTP,
+                        url=entry.get("url"),
+                        headers=self._string_mapping(entry.get("headers"), "headers"),
+                    ))
+                else:
+                    warnings.warn(
+                        f"Skipping malformed MCP entry '{name}': "
+                        "unsupported or missing transport",
+                        UserWarning,
+                        stacklevel=2,
+                    )
+            except (TypeError, ValueError) as error:
+                warnings.warn(
+                    f"Skipping malformed MCP entry '{name}': {error}",
+                    UserWarning,
+                    stacklevel=2,
+                )
+
+        return result

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/tests/integration/test_copilot_cli_integration.py

@@ -224,6 +224,19 @@ class TestCommandConstructionIntegration:
         assert "--effort" in cmd_args
         assert cmd_args[cmd_args.index("--effort") + 1] == "high"
 
+    async def test_execute_omits_effort_flag_for_empty_string(self):
+        # Arrange
+        shell = AgentShell(agent_type=AgentType.COPILOT_CLI)
+        ndjson = [MESSAGE_DELTA_EVENT, RESULT_EVENT_SUCCESS]
+        mock_process = _make_mock_process(ndjson)
+
+        # Act
+        with patch("asyncio.create_subprocess_exec", return_value=mock_process) as mock_exec:
+            await shell.execute(cwd="/tmp", prompt="test", effort="")
+
+        # Assert
+        assert "--effort" not in mock_exec.call_args[0]
+
     async def test_prompt_is_second_argument(self):
         # Arrange
         shell = AgentShell(agent_type=AgentType.COPILOT_CLI)

agent_shell_py-0.2.5/tests/integration/test_cursor_mcp_integration.py

@@ -0,0 +1,367 @@
+import json
+import stat
+from pathlib import Path
+
+import pytest
+
+from agent_shell.shell import AgentShell
+from agent_shell.models.agent import AgentType, MCPServerSpec, MCPServerType
+
+
+@pytest.fixture
+def isolated_home(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    return tmp_path
+
+
+def _read_config(home: Path) -> dict:
+    return json.loads((home / ".cursor" / "mcp.json").read_text())
+
+
+class TestCursorMcp:
+    async def test_adds_stdio_server_to_user_config(self, isolated_home):
+        # Arrange
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+        spec = MCPServerSpec(
+            name="forgetful",
+            type=MCPServerType.STDIO,
+            command="uvx",
+            args=["forgetful-ai"],
+            env={"FORGETFUL_API_KEY": "secret"},
+        )
+
+        # Act
+        await shell.add_mcp_server(spec)
+
+        # Assert
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        assert _read_config(isolated_home) == {
+            "mcpServers": {
+                "forgetful": {
+                    "command": "uvx",
+                    "args": ["forgetful-ai"],
+                    "env": {"FORGETFUL_API_KEY": "secret"},
+                }
+            }
+        }
+        assert stat.S_IMODE(config_path.stat().st_mode) == 0o600
+
+    async def test_failed_atomic_replace_preserves_existing_config(
+            self,
+            isolated_home,
+            monkeypatch,
+    ):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        original = {"mcpServers": {"existing": {"command": "existing-command"}}}
+        config_path.write_text(json.dumps(original))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        def fail_replace(source, destination):
+            raise OSError("simulated replace failure")
+
+        monkeypatch.setattr("agent_shell.adapters.cursor_adapter.os.replace", fail_replace)
+
+        # Act / Assert
+        with pytest.raises(OSError, match="simulated replace failure"):
+            await shell.add_mcp_server(MCPServerSpec(
+                name="new",
+                type=MCPServerType.STDIO,
+                command="new-command",
+            ))
+
+        assert _read_config(isolated_home) == original
+        assert list(config_path.parent.iterdir()) == [config_path]
+
+    async def test_add_rejects_malformed_server_collection_without_writing(
+            self,
+            isolated_home,
+    ):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        original = {"mcpServers": ["broken"]}
+        config_path.write_text(json.dumps(original))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act / Assert
+        with pytest.raises(ValueError, match="mcpServers"):
+            await shell.add_mcp_server(MCPServerSpec(
+                name="new",
+                type=MCPServerType.STDIO,
+                command="new-command",
+            ))
+
+        assert _read_config(isolated_home) == original
+
+    async def test_same_transport_update_preserves_cursor_only_fields(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "local": {
+                    "type": "stdio",
+                    "command": "old-command",
+                    "args": ["old-arg"],
+                    "env": {"OLD": "value"},
+                    "envFile": "~/.cursor/mcp.env",
+                }
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+        replacement = MCPServerSpec(
+            name="local",
+            type=MCPServerType.STDIO,
+            command="new-command",
+            args=["new-arg"],
+            env={"NEW": "value"},
+        )
+
+        # Act
+        await shell.add_mcp_server(replacement)
+
+        # Assert
+        assert _read_config(isolated_home)["mcpServers"]["local"] == {
+            "type": "stdio",
+            "command": "new-command",
+            "args": ["new-arg"],
+            "env": {"NEW": "value"},
+            "envFile": "~/.cursor/mcp.env",
+        }
+
+    async def test_remote_update_preserves_auth_and_sse_type(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "remote": {
+                    "type": "sse",
+                    "url": "https://old.example.com/sse",
+                    "headers": {"OLD": "value"},
+                    "auth": {"CLIENT_ID": "client-id"},
+                }
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+        replacement = MCPServerSpec(
+            name="remote",
+            type=MCPServerType.HTTP,
+            url="https://new.example.com/sse",
+            headers={"NEW": "value"},
+        )
+
+        # Act
+        await shell.add_mcp_server(replacement)
+
+        # Assert
+        assert _read_config(isolated_home)["mcpServers"]["remote"] == {
+            "type": "sse",
+            "url": "https://new.example.com/sse",
+            "headers": {"NEW": "value"},
+            "auth": {"CLIENT_ID": "client-id"},
+        }
+
+    async def test_transport_change_drops_old_transport_fields(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "changing": {
+                    "type": "stdio",
+                    "command": "old-command",
+                    "envFile": "~/.cursor/mcp.env",
+                }
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        await shell.add_mcp_server(MCPServerSpec(
+            name="changing",
+            type=MCPServerType.HTTP,
+            url="https://example.com/mcp",
+        ))
+
+        # Assert
+        assert _read_config(isolated_home)["mcpServers"]["changing"] == {
+            "url": "https://example.com/mcp",
+            "headers": {},
+        }
+
+    async def test_adds_http_server_without_replacing_existing_config(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {"existing": {"command": "existing-command"}},
+            "unrelated": {"preserve": True},
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+        spec = MCPServerSpec(
+            name="remote",
+            type=MCPServerType.HTTP,
+            url="https://example.com/mcp",
+            headers={"Authorization": "Bearer secret"},
+        )
+
+        # Act
+        await shell.add_mcp_server(spec)
+
+        # Assert
+        assert _read_config(isolated_home) == {
+            "mcpServers": {
+                "existing": {"command": "existing-command"},
+                "remote": {
+                    "url": "https://example.com/mcp",
+                    "headers": {"Authorization": "Bearer secret"},
+                },
+            },
+            "unrelated": {"preserve": True},
+        }
+
+    async def test_removes_server_without_replacing_existing_config(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "forgetful": {"command": "uvx"},
+                "existing": {"command": "existing-command"},
+            },
+            "unrelated": {"preserve": True},
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        await shell.remove_mcp_server("forgetful")
+
+        # Assert
+        assert _read_config(isolated_home) == {
+            "mcpServers": {"existing": {"command": "existing-command"}},
+            "unrelated": {"preserve": True},
+        }
+
+    async def test_remove_warns_when_server_is_missing(self, isolated_home):
+        # Arrange
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act / Assert
+        with pytest.warns(UserWarning, match="not found"):
+            await shell.remove_mcp_server("missing")
+
+        assert not (isolated_home / ".cursor" / "mcp.json").exists()
+
+    async def test_lists_stdio_and_http_servers_from_user_config(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "forgetful": {
+                    "command": "uvx",
+                    "args": ["forgetful-ai"],
+                    "env": {"K": "V"},
+                },
+                "remote": {
+                    "url": "https://example.com/mcp",
+                    "headers": {"Authorization": "Bearer secret"},
+                },
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        servers = await shell.list_mcp_servers()
+
+        # Assert
+        assert servers == [
+            MCPServerSpec(
+                name="forgetful",
+                type=MCPServerType.STDIO,
+                command="uvx",
+                args=["forgetful-ai"],
+                env={"K": "V"},
+            ),
+            MCPServerSpec(
+                name="remote",
+                type=MCPServerType.HTTP,
+                url="https://example.com/mcp",
+                headers={"Authorization": "Bearer secret"},
+            ),
+        ]
+
+    async def test_list_honours_explicit_transport_type(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "legacy-sse": {
+                    "type": "sse",
+                    "url": "https://example.com/sse",
+                    "command": "must-not-win",
+                }
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        servers = await shell.list_mcp_servers()
+
+        # Assert
+        assert servers == [MCPServerSpec(
+            name="legacy-sse",
+            type=MCPServerType.HTTP,
+            url="https://example.com/sse",
+        )]
+
+    async def test_list_skips_malformed_entries_with_warnings(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({
+            "mcpServers": {
+                "not-an-object": "broken",
+                "missing-transport": {"args": ["orphaned"]},
+                "invalid-args": {"command": "uvx", "args": 42},
+                "string-args": {"command": "uvx", "args": "--port"},
+                "invalid-env": {"command": "uvx", "env": {"PORT": 42}},
+                "good": {"command": "good-command"},
+            }
+        }))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        with pytest.warns(UserWarning) as captured:
+            servers = await shell.list_mcp_servers()
+
+        # Assert
+        messages = [str(warning.message) for warning in captured]
+        assert any("not-an-object" in message for message in messages)
+        assert any("missing-transport" in message for message in messages)
+        assert any("invalid-args" in message for message in messages)
+        assert any("string-args" in message for message in messages)
+        assert any("invalid-env" in message for message in messages)
+        assert servers == [MCPServerSpec(
+            name="good",
+            type=MCPServerType.STDIO,
+            command="good-command",
+        )]
+
+    async def test_list_warns_when_mcp_servers_is_not_an_object(self, isolated_home):
+        # Arrange
+        config_path = isolated_home / ".cursor" / "mcp.json"
+        config_path.parent.mkdir(parents=True)
+        config_path.write_text(json.dumps({"mcpServers": ["broken"]}))
+        shell = AgentShell(agent_type=AgentType.CURSOR)
+
+        # Act
+        with pytest.warns(UserWarning, match="mcpServers"):
+            servers = await shell.list_mcp_servers()
+
+        # Assert
+        assert servers == []

{agent_shell_py-0.2.4 → agent_shell_py-0.2.5}/tests/integration/test_process_lifecycle.py

@@ -244,11 +244,15 @@ async def test_guardian_does_not_inherit_the_owners_file_descriptors(tmp_path):
     guardian = process_cleanup._guardians[process]
 
     try:
-        # Act
-        guardian_fds = {
-            fd: os.readlink(f"/proc/{guardian.pid}/fd/{fd}")
-            for fd in os.listdir(f"/proc/{guardian.pid}/fd")
-        }
+        # Act — /proc is a live view: an fd can close after listdir() but before readlink().
+        # That normal Linux race made the tag build flaky with FileNotFoundError. Ignore only
+        # entries that vanished; any descriptor still open is captured and asserted below.
+        guardian_fds: dict[str, str] = {}
+        for fd in os.listdir(f"/proc/{guardian.pid}/fd"):
+            try:
+                guardian_fds[fd] = os.readlink(f"/proc/{guardian.pid}/fd/{fd}")
+            except FileNotFoundError:
+                continue
 
         # Assert — a guardian must not keep an owner's output pipe, log, or native FD open.
         assert guardian_fds["1"] == "/dev/null"

agent_shell_py-0.2.4/tests/integration/test_cursor_mcp_integration.py

@@ -1,36 +0,0 @@
-import pytest
-
-from agent_shell.shell import AgentShell
-from agent_shell.models.agent import AgentType, MCPServerSpec, MCPServerType
-
-
-class TestCursorMcpNotImplemented:
-    # Cursor's `mcp` subcommands are login/list/list-tools/enable/disable ONLY — no add/remove.
-    # Servers are declared in .cursor/mcp.json, and `mcp list` reports only `name: status`
-    # (not the transport/command/url MCPServerSpec needs), so no method can be faithfully
-    # supported. They must fail loud, not silently no-op.
-    async def test_add_mcp_server_raises(self):
-        # Arrange
-        shell = AgentShell(agent_type=AgentType.CURSOR)
-        spec = MCPServerSpec(name="forgetful", type=MCPServerType.STDIO, command="uvx",
-                             args=["forgetful-ai"])
-
-        # Act / Assert
-        with pytest.raises(NotImplementedError):
-            await shell.add_mcp_server(spec)
-
-    async def test_remove_mcp_server_raises(self):
-        # Arrange
-        shell = AgentShell(agent_type=AgentType.CURSOR)
-
-        # Act / Assert
-        with pytest.raises(NotImplementedError):
-            await shell.remove_mcp_server("forgetful")
-
-    async def test_list_mcp_servers_raises(self):
-        # Arrange
-        shell = AgentShell(agent_type=AgentType.CURSOR)
-
-        # Act / Assert
-        with pytest.raises(NotImplementedError):
-            await shell.list_mcp_servers()