apm-cli 0.31.0__tar.gz → 0.33.0__tar.gz

{apm_cli-0.31.0/src/apm_cli.egg-info → apm_cli-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.31.0
+Version: 0.33.0
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -67,7 +67,7 @@ Requires-Dist: pylint>=3.0.0; extra == "dev"
 Requires-Dist: hypothesis>=6.0.0; extra == "dev"
 Requires-Dist: mutmut==3.6.0; extra == "dev"
 Provides-Extra: build
-Requires-Dist: pyinstaller>=6.0.0; extra == "build"
+Requires-Dist: pyinstaller>=6.17.0; extra == "build"
 Dynamic: license-file
 
 # APM – Agent Package Manager

{apm_cli-0.31.0 → apm_cli-0.33.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.31.0"
+version = "0.33.0"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -56,7 +56,7 @@ dev = [
     "mutmut==3.6.0",
 ]
 build = [
-    "pyinstaller>=6.0.0",
+    "pyinstaller>=6.17.0",
 ]
 
 [project.scripts]
@@ -205,6 +205,7 @@ markers = [
     "slow: marks tests as slow running tests",
     "benchmark: marks performance benchmark tests (deselected by default, run with -m benchmark)",
     "windows_compat: load-bearing cross-platform regression contract family (CRLF-safe atomic writes, portable path formatting, git-executable resolution, socket/thread shutdown); runs on every OS and is additionally selected by the PR-time Windows Compatibility Gate -- NOT a requires_windows skip-gate, do not use requires_windows for this",
+    "trusted_executable: native trusted git/gh discovery and real consumer regressions; additionally selected on Windows Python 3.10 and 3.11",
     "requires_e2e_mode: requires APM_E2E_TESTS=1",
     "requires_github_token: requires GITHUB_APM_PAT or GITHUB_TOKEN",
     "requires_ado_pat: requires ADO_APM_PAT",

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/base.py

@@ -1424,7 +1424,7 @@ class MCPClientAdapter(ABC):
 
         Args:
             config: Mutable config dict updated in place.
-            remote: Registry remote entry (may contain a ``"headers"`` list).
+            remote: Registry remote entry (headers may be records or a mapping).
             server_info: Registry server metadata used for name / URL lookup.
             env_overrides: Caller-supplied env-var override mapping.
             runtime_label: Label for diagnostic messages.
@@ -1432,18 +1432,38 @@ class MCPClientAdapter(ABC):
                 instantiate.  Passed by the caller so tests can patch the right
                 module-level name.
         """
+        from ...core.auth import AuthResolver
+        from ...models.dependency.mcp import ManifestHeaderValue
+
         server_name = server_info.get("name", "")
         is_github_server = self._is_github_server(server_name, remote.get("url", ""))
         local_token_injected = False
-        if is_github_server:
-            _tm = token_manager_class()
-            github_token = _tm.get_token_for_purpose("copilot") or os.getenv(
-                "GITHUB_PERSONAL_ACCESS_TOKEN"
+        headers = remote.get("headers", []) or []
+        if isinstance(headers, dict):
+            headers = [{"name": name, "value": value} for name, value in headers.items()]
+        explicit_authorization = any(
+            isinstance(header, dict)
+            and isinstance(header.get("name"), str)
+            and header["name"].casefold() == "authorization"
+            and isinstance(header.get("value"), ManifestHeaderValue)
+            and bool(header.get("value"))
+            for header in headers
+        )
+        if is_github_server and not explicit_authorization:
+            resolver = AuthResolver(
+                token_manager=token_manager_class(), allow_external_fallback=False
+            )
+            selected = resolver.resolve_github_mcp_token(
+                source_only=self._supports_runtime_env_substitution
             )
-            if github_token:
-                config["headers"] = {"Authorization": f"Bearer {github_token}"}
+            if selected:
+                credential = (
+                    self._format_runtime_env_placeholder(selected)
+                    if self._supports_runtime_env_substitution
+                    else selected
+                )
+                config.setdefault("headers", {})["Authorization"] = f"Bearer {credential}"
                 local_token_injected = True
-        headers = remote.get("headers", [])
         if headers:
             if "headers" not in config:
                 config["headers"] = {}
@@ -1451,8 +1471,15 @@ class MCPClientAdapter(ABC):
                 header_name = header.get("name", "")
                 header_value = header.get("value", "")
                 if header_name and header_value:
-                    if header_name == "Authorization" and local_token_injected:
-                        continue
+                    if header_name.casefold() == "authorization":
+                        if local_token_injected or (
+                            explicit_authorization
+                            and not isinstance(header_value, ManifestHeaderValue)
+                        ):
+                            continue
+                        for key in list(config["headers"]):
+                            if key.casefold() == "authorization":
+                                del config["headers"][key]
                     resolved_value = self._resolve_env_variable(
                         header_name, header_value, env_overrides
                     )

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/claude.py

@@ -63,6 +63,14 @@ class ClaudeClientAdapter(CopilotClientAdapter):
     _CONVERGED_SKILL_PREFIX = ".agents/skills/"
     _CLAUDE_SKILL_PREFIX = ".claude/skills/"
 
+    # Entry ``type`` values Claude Code uses for URL-addressed servers.
+    _REMOTE_TYPES = ("http", "sse", "streamable-http")
+
+    # Transport fields are replaced across families; a partial update can
+    # retain an omitted type only when it still belongs to the selected family.
+    _REMOTE_TRANSPORT_KEYS = frozenset({"type", "url", "headers"})
+    _STDIO_TRANSPORT_KEYS = frozenset({"type", "command", "args", "env", "cwd"})
+
     @classmethod
     def _rewrite_self_defined_skill_command(cls, command: str) -> str:
         if isinstance(command, str) and command.startswith(cls._CONVERGED_SKILL_PREFIX):
@@ -75,8 +83,13 @@ class ClaudeClientAdapter(CopilotClientAdapter):
             config["command"] = self._rewrite_self_defined_skill_command(config["command"])
         return config
 
-    @staticmethod
-    def _normalize_mcp_entry_for_claude_code(entry: dict) -> dict:
+    @classmethod
+    def _is_remote_mcp_entry(cls, entry: dict) -> bool:
+        """Return whether *entry* describes a remote (URL-addressed) server."""
+        return bool(entry.get("url")) or entry.get("type") in cls._REMOTE_TYPES
+
+    @classmethod
+    def _normalize_mcp_entry_for_claude_code(cls, entry: dict) -> dict:
         """Normalize a server entry to Claude Code's on-disk shape.
 
         For remote servers, keep ``type``/``url``/``headers`` per Claude
@@ -91,11 +104,8 @@ class ClaudeClientAdapter(CopilotClientAdapter):
         if not isinstance(entry, dict):
             return entry
         out = dict(entry)
-        url = out.get("url")
-        t = out.get("type")
-        is_remote = bool(url) or t in ("http", "sse", "streamable-http")
 
-        if is_remote:
+        if cls._is_remote_mcp_entry(out):
             if out.get("id") in ("", None):
                 out.pop("id", None)
             if out.get("tools") == ["*"]:
@@ -110,14 +120,43 @@ class ClaudeClientAdapter(CopilotClientAdapter):
             out.pop("id", None)
         return out
 
-    @staticmethod
-    def _merge_mcp_server_dicts(existing_servers: dict, config_updates: dict) -> None:
+    @classmethod
+    def _retained_previous_entry(cls, prev: dict, new_cfg: dict) -> dict:
+        """Return *prev* without the keys of the transport *new_cfg* is not.
+
+        A redeclaration that switches transport must not leave the previous
+        transport's keys behind.  A surviving ``url`` keeps the entry
+        classified as remote, so the stdio shape never wins and a stale
+        ``Authorization`` header stays in the Claude Code config.
+
+        The keys are selected from the update rather than from a comparison
+        of the two entries, so an entry already carrying both transports --
+        written by a release that merged them unconditionally -- is repaired
+        by the next install that writes it instead of matching its own mixed shape and
+        surviving.  Keys APM does not manage (hand-authored OAuth blocks and
+        the like) describe no transport and are retained either way.
+        """
+        declares_transport = any(new_cfg.get(key) for key in ("type", "url", "command"))
+        is_remote = cls._is_remote_mcp_entry(new_cfg if declares_transport else prev)
+        stale = cls._STDIO_TRANSPORT_KEYS if is_remote else cls._REMOTE_TRANSPORT_KEYS
+        compatible_types = cls._REMOTE_TYPES if is_remote else ("local", "stdio")
+        # Keep a compatible type in place so repeated writes retain field order.
+        return {
+            key: value
+            for key, value in prev.items()
+            if key not in stale or (key == "type" and value in compatible_types)
+        }
+
+    @classmethod
+    def _merge_mcp_server_dicts(cls, existing_servers: dict, config_updates: dict) -> None:
         """Merge *config_updates* into *existing_servers* in place.
 
         Per-server entries are shallow-merged: ``{**old, **new}`` so keys present
-        only on plugin- or hand-authored configs (e.g. ``type``, OAuth blocks)
+        only on plugin- or hand-authored configs (e.g. OAuth blocks)
         survive when an update omits them.  Keys in *new* overwrite *old* on
         conflict so APM/registry installs still refresh ``command``/``args``/etc.
+        The previous entry first drops the keys of the transport the update
+        does not declare, so the merged entry describes exactly one.
         """
         for name, new_cfg in config_updates.items():
             if not isinstance(new_cfg, dict):
@@ -125,7 +164,7 @@ class ClaudeClientAdapter(CopilotClientAdapter):
                 continue
             prev = existing_servers.get(name)
             if isinstance(prev, dict):
-                merged = {**prev, **new_cfg}
+                merged = {**cls._retained_previous_entry(prev, new_cfg), **new_cfg}
                 existing_servers[name] = merged
             else:
                 existing_servers[name] = dict(new_cfg)

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/codex.py

@@ -2,6 +2,7 @@
 
 import logging
 import os
+import re
 from pathlib import Path
 from urllib.parse import urlparse
 
@@ -15,10 +16,34 @@ from ...utils.console import _rich_success, _rich_warning
 from ...utils.net import is_loopback_host
 from ...utils.path_security import PathTraversalError
 from ._mcp_runtime_args import process_v01_value_hint_arg
-from .base import MCPClientAdapter
+from .base import _ENV_VAR_RE, MCPClientAdapter
 
 _log = logging.getLogger(__name__)
 
+# Codex documents ``http_headers`` as a map of header names to STATIC values,
+# so a ``${VAR}`` written there reaches the server as that literal text. An
+# environment-sourced header has two dedicated fields instead:
+# ``env_http_headers`` maps a header name to the variable holding its whole
+# value, and ``bearer_token_env_var`` names the variable holding an
+# Authorization bearer token. Codex resolves both at server start, which is
+# what the declared ``${VAR}`` asks for -- this adapter does not support
+# runtime substitution itself, so the placeholder survives
+# ``_resolve_variable_placeholders`` untouched.
+# See https://learn.chatgpt.com/docs/extend/mcp?surface=cli
+_CODEX_BEARER_HEADER = "authorization"
+# Reuse the canonical placeholder syntax so the two spellings APM accepts
+# (``${VAR}`` and ``${env:VAR}``) cannot drift apart here. The auth scheme is
+# case-insensitive per RFC 7235; Codex always writes it as ``Bearer``.
+_CODEX_BEARER_VALUE_RE = re.compile(rf"(?i:Bearer) +{_ENV_VAR_RE.pattern}")
+# Any reference still standing in a resolved value, deliberately wider than the
+# canonical parser: a spelling it does not model, such as the shell default in
+# ``${VAR:-}``, is no more static than a ``${VAR}`` Codex could resolve, and
+# writing it to ``http_headers`` sends the braces to the server. Widening the
+# report here, rather than the parser, keeps every other adapter's placeholder
+# semantics untouched. ``${input:...}`` is excluded: input variables are
+# collected elsewhere and carry their own warning.
+_CODEX_UNSUPPORTED_REFERENCE_RE = re.compile(r"\$\{(?!input:)")
+
 
 class CodexClientAdapter(MCPClientAdapter):
     """Codex CLI implementation of MCP client adapter.
@@ -293,16 +318,49 @@ class CodexClientAdapter(MCPClientAdapter):
                 "id": server_info.get("id", ""),
             }
             http_headers: dict[str, str] = {}
+            env_http_headers: dict[str, str] = {}
+            bearer_token_env_var = ""
+            unsupported_headers: list[str] = []
             for header in remote.get("headers", []):
                 h_name = header.get("name", "")
                 h_value = header.get("value", "")
-                if h_name and h_value:
-                    http_headers[h_name] = self._resolve_variable_placeholders(
-                        h_value, env_overrides or {}, runtime_vars or {}
-                    )
+                if not (h_name and h_value):
+                    continue
+                resolved = self._resolve_variable_placeholders(
+                    h_value, env_overrides or {}, runtime_vars or {}
+                )
+                bearer = _CODEX_BEARER_VALUE_RE.fullmatch(resolved)
+                if bearer and h_name.lower() == _CODEX_BEARER_HEADER:
+                    bearer_token_env_var = bearer.group(1)
+                    continue
+                env_header = _ENV_VAR_RE.fullmatch(resolved)
+                if env_header:
+                    env_http_headers[h_name] = env_header.group(1)
+                    continue
+                if _CODEX_UNSUPPORTED_REFERENCE_RE.search(resolved):
+                    unsupported_headers.append(h_name)
+                    continue
+                http_headers[h_name] = resolved
+            if unsupported_headers:
+                safe_headers = ", ".join(ascii(name)[1:-1] for name in unsupported_headers)
+                safe_server = ascii(server_name)[1:-1]
+                _rich_warning(
+                    f"Skipping header(s) {safe_headers} of MCP server "
+                    f"'{safe_server}' for Codex CLI: Codex reads a header from the "
+                    "environment only when the value is exactly ${VAR} or, for "
+                    "Authorization, `Bearer ${VAR}`. Literal text around the "
+                    "reference, or a shell-style default such as ${VAR:-}, has no "
+                    "Codex equivalent; export the whole header value as one variable.",
+                    symbol="warning",
+                )
+            # Scalars precede the sub-tables tomlkit renders for the dict values.
+            if bearer_token_env_var:
+                remote_config["bearer_token_env_var"] = bearer_token_env_var
             if http_headers:
                 remote_config["http_headers"] = http_headers
                 self._warn_input_variables(http_headers, server_name, "Codex CLI")
+            if env_http_headers:
+                remote_config["env_http_headers"] = env_http_headers
             self._merge_extra(remote_config, server_info)
             return remote_config
 

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/copilot.py

@@ -55,11 +55,12 @@ class CopilotClientAdapter(MCPClientAdapter):
     # environment and the literal value is baked into the config file
     # (legacy pre-#1152 behaviour).
     #
-    # Subclasses (Cursor / Windsurf / OpenCode / Claude / Gemini) override
-    # this to ``False`` until their respective config formats are individually
-    # audited for runtime-substitution support. Critically, Claude Desktop's
-    # config format does NOT support runtime substitution -- it MUST keep
-    # resolving at install time.
+    # Subclasses (Windsurf / OpenCode / Claude / Gemini) override this to
+    # ``False`` until their respective config formats are individually audited
+    # for runtime-substitution support. Cursor has audited native
+    # ``${env:VAR}`` support. Critically, Claude Desktop's config format does
+    # NOT support runtime substitution -- it MUST keep resolving at install
+    # time.
     _supports_runtime_env_substitution: bool = True
 
     # Process-wide aggregation of legacy ``<VAR>`` offenders, keyed by

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/cursor.py

@@ -14,6 +14,8 @@ import os
 from pathlib import Path
 
 from ...core.token_manager import GitHubTokenManager
+from ...models.dependency.mcp import TrustedEnvLiteral
+from .base import _stringify_env_literal
 from .copilot import CopilotClientAdapter
 
 
@@ -29,11 +31,43 @@ class CursorClientAdapter(CopilotClientAdapter):
     target_name: str = "cursor"
     mcp_servers_key: str = "mcpServers"
 
-    # Cursor's mcp.json runtime-substitution support has not yet been
-    # individually audited (see #1152). Pin to the legacy install-time
-    # resolution behaviour so this adapter is unchanged by the Copilot
-    # security fix; revisit in a follow-up.
-    _supports_runtime_env_substitution: bool = False
+    # APM normalizes Cursor env, args, and headers to ${env:NAME}, not command/url.
+    # Keep manifest env references native in the project-local config, so
+    # those referenced values are not baked into the file. Explicit mcp.env
+    # literals remain literal below; shared GitHub token injection is separate.
+    _supports_runtime_env_substitution: bool = True
+
+    def _format_runtime_env_placeholder(self, name: str) -> str:
+        """Return Cursor's native env-var placeholder syntax."""
+        return "${env:" + name + "}"
+
+    def _resolve_environment_variables(
+        self,
+        env_vars: dict[str, object] | list[dict[str, object]],
+        env_overrides: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        """Translate explicit env references while preserving authored literals.
+
+        APM's shared translate-mode dict resolver treats ordinary string
+        values as candidates for environment substitution. In Cursor's
+        project-local config, an explicit static value must keep its authored
+        value; only recognized references are rewritten for Cursor.
+        """
+        if not isinstance(env_vars, dict):
+            return super()._resolve_environment_variables(env_vars, env_overrides)
+
+        resolved: dict[str, str] = {}
+        self._last_env_placeholder_keys = set()
+        for name, value in env_vars.items():
+            if not name or value is None:
+                continue
+            if isinstance(value, TrustedEnvLiteral):
+                resolved[name] = value
+            elif isinstance(value, str):
+                resolved[name] = self._resolve_env_variable(name, value, env_overrides)
+            else:
+                resolved[name] = _stringify_env_literal(value)
+        return resolved
 
     # ------------------------------------------------------------------ #
     # Auth-header injection override (for testability)
@@ -42,14 +76,21 @@ class CursorClientAdapter(CopilotClientAdapter):
     def _apply_auth_and_headers(
         self, config, remote, server_info, env_overrides, runtime_label="Cursor"
     ):
-        """Inject GitHub token and registry-supplied headers into *config*.
+        """Merge registry headers without persisting a resolved GitHub token.
 
         Overrides the parent to supply ``GitHubTokenManager`` from *this*
         module's namespace, allowing tests to patch
-        ``apm_cli.adapters.client.cursor.GitHubTokenManager`` correctly.
+        ``apm_cli.adapters.client.cursor.GitHubTokenManager`` correctly. Cursor
+        reads project-local config, so GitHub credentials must be supplied as
+        runtime environment references rather than resolved during install.
         """
         self._apply_auth_and_headers_impl(
-            config, remote, server_info, env_overrides, runtime_label, GitHubTokenManager
+            config,
+            remote,
+            server_info,
+            env_overrides,
+            runtime_label,
+            GitHubTokenManager,
         )
 
     def get_config_path(self):

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/adapters/client/opencode.py

@@ -29,8 +29,9 @@ already exists — OpenCode support is opt-in.
 import json
 import os
 from pathlib import Path
+from typing import Any
 
-from ...models.dependency.mcp import _EXTRA_DENYLIST
+from ...models.dependency.mcp import _EXTRA_DENYLIST, opencode_enabled_value
 from .copilot import CopilotClientAdapter
 
 
@@ -55,7 +56,7 @@ class OpenCodeClientAdapter(CopilotClientAdapter):
         """Return the path to ``opencode.json`` in the repository root."""
         return str(self.project_root / "opencode.json")
 
-    def update_config(self, config_updates, enabled=True):
+    def update_config(self, config_updates, enabled: Any = True):
         """Merge *config_updates* into the ``mcp`` section of ``opencode.json``.
 
         The ``.opencode/`` directory must already exist; if it does not, this
@@ -94,7 +95,7 @@ class OpenCodeClientAdapter(CopilotClientAdapter):
         self,
         server_url,
         server_name=None,
-        enabled=True,
+        enabled: Any = True,
         env_overrides=None,
         server_info_cache=None,
         runtime_vars=None,
@@ -120,7 +121,10 @@ class OpenCodeClientAdapter(CopilotClientAdapter):
             config_key = self._determine_config_key(server_url, server_name)
 
             server_config = self._format_server_config(server_info, env_overrides, runtime_vars)
-            self.update_config({config_key: server_config}, enabled=enabled)
+            self.update_config(
+                {config_key: server_config},
+                enabled=opencode_enabled_value(server_info, enabled),
+            )
 
             print(f"Successfully configured MCP server '{config_key}' for OpenCode")
             return True
@@ -130,7 +134,7 @@ class OpenCodeClientAdapter(CopilotClientAdapter):
             return False
 
     @staticmethod
-    def _to_opencode_format(copilot_entry: dict, enabled: bool = True) -> dict:
+    def _to_opencode_format(copilot_entry: dict, enabled: Any = True) -> dict:
         """Convert a Copilot-format server config to OpenCode format.
 
         Copilot: ``{"command": "npx", "args": ["-y", "pkg"], "env": {...}}``

{apm_cli-0.31.0 → apm_cli-0.33.0}/src/apm_cli/cache/git_cache.py

@@ -33,6 +33,7 @@ import re
 import subprocess
 from pathlib import Path
 
+from ..utils.atomic_io import atomic_write_text
 from ..utils.git_sparse import apply_sparse_cone, repair_dangling_cone_symlinks
 from ..utils.path_security import ensure_path_within
 from .integrity import verify_checkout_sha
@@ -278,6 +279,31 @@ class GitCache:
             promisor_url=url if use_partial else None,
         )
 
+    def _resolved_ref_path(self, url: str, ref: str) -> Path:
+        digest = hashlib.sha256(ref.encode("utf-8")).hexdigest()
+        path = self._db_root / f"{cache_shard_key(url)}-{digest}.ref"
+        ensure_path_within(path, self._db_root)
+        return path
+
+    def remember_resolved_ref(self, url: str, ref: str, sha: str) -> None:
+        """Persist an authorized remote observation independently of bare flavor."""
+        if not ref or not _SHA_RE.fullmatch(sha):
+            raise ValueError("A remote ref observation requires a ref and full SHA")
+        path = self._resolved_ref_path(url, ref)
+        with shard_lock(path):
+            atomic_write_text(path, sha.lower(), new_file_mode=0o600)
+
+    def read_resolved_ref(self, url: str, ref: str) -> tuple[bool, str | None]:
+        """Return receipt presence and SHA; corrupt receipts must not revive old refs."""
+        path = self._resolved_ref_path(url, ref)
+        try:
+            sha = path.read_text(encoding="ascii")
+        except FileNotFoundError:
+            return False, None
+        except (OSError, UnicodeError):
+            return True, None
+        return True, sha if _SHA_RE.fullmatch(sha) else None
+
     def _record_checkout_access(self, checkout_dir: Path) -> Path:
         """Record successful reuse of a finalized checkout under its shard lock."""
         # Pruning ages the shared SHA root, not individual checkout variants.
@@ -960,6 +986,8 @@ class GitCache:
                 if entry.is_dir(follow_symlinks=False) and not entry.name.endswith(".lock"):
                     db_count += 1
                     total_size += _dir_size(Path(entry.path))
+                elif entry.name.endswith(".ref") and entry.is_file(follow_symlinks=False):
+                    total_size += entry.stat(follow_symlinks=False).st_size
 
         if self._checkouts_root.is_dir():
             for shard_entry in os.scandir(str(self._checkouts_root)):