apm-cli 0.7.9__tar.gz → 0.8.1__tar.gz

{apm_cli-0.7.9/src/apm_cli.egg-info → apm_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.7.9
+Version: 0.8.1
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -65,7 +65,7 @@ Dynamic: license-file
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code
+GitHub Copilot · Claude Code · Cursor · OpenCode
 
 **[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)**
 
@@ -88,7 +88,7 @@ dependencies:
     # Specific agent primitives from any repository
     - github/awesome-copilot/agents/api-architect.agent.md
     # A full APM package with instructions, skills, prompts, hooks...
-    - microsoft/apm-sample-package
+    - microsoft/apm-sample-package#v1.0.0
 ```
 
 ```bash
@@ -101,7 +101,8 @@ apm install    # every agent is configured
 - **One manifest for everything** — instructions, skills, prompts, agents, hooks, plugins, MCP servers
 - **Install from anywhere** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, any git host
 - **Transitive dependencies** — packages can depend on packages; APM resolves the full tree
-- **Compile to standards** — `apm compile` produces `AGENTS.md` (GitHub Copilot) and `CLAUDE.md` (Claude Code)
+- **Compile to standards** — `apm compile` produces `AGENTS.md` (GitHub Copilot, OpenCode), `CLAUDE.md` (Claude Code), and `.cursor/rules/` (Cursor)
+- **Content security** — `apm audit` scans for hidden Unicode characters; `apm install` blocks compromised packages before agents can read them
 - **Create & share** — `apm pack` bundles your current configuration as a zipped package
 - **CI/CD ready** — [GitHub Action](https://github.com/microsoft/apm-action) for automated workflows
 
@@ -148,7 +149,7 @@ pip install apm-cli
 Then start adding packages:
 
 ```bash
-apm install microsoft/apm-sample-package
+apm install microsoft/apm-sample-package#v1.0.0
 ```
 
 See the **[Getting Started guide](https://microsoft.github.io/apm/getting-started/quick-start/)** for the full walkthrough.

{apm_cli-0.7.9 → apm_cli-0.8.1}/README.md

@@ -4,7 +4,7 @@
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code
+GitHub Copilot · Claude Code · Cursor · OpenCode
 
 **[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)**
 
@@ -27,7 +27,7 @@ dependencies:
     # Specific agent primitives from any repository
     - github/awesome-copilot/agents/api-architect.agent.md
     # A full APM package with instructions, skills, prompts, hooks...
-    - microsoft/apm-sample-package
+    - microsoft/apm-sample-package#v1.0.0
 ```
 
 ```bash
@@ -40,7 +40,8 @@ apm install    # every agent is configured
 - **One manifest for everything** — instructions, skills, prompts, agents, hooks, plugins, MCP servers
 - **Install from anywhere** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, any git host
 - **Transitive dependencies** — packages can depend on packages; APM resolves the full tree
-- **Compile to standards** — `apm compile` produces `AGENTS.md` (GitHub Copilot) and `CLAUDE.md` (Claude Code)
+- **Compile to standards** — `apm compile` produces `AGENTS.md` (GitHub Copilot, OpenCode), `CLAUDE.md` (Claude Code), and `.cursor/rules/` (Cursor)
+- **Content security** — `apm audit` scans for hidden Unicode characters; `apm install` blocks compromised packages before agents can read them
 - **Create & share** — `apm pack` bundles your current configuration as a zipped package
 - **CI/CD ready** — [GitHub Action](https://github.com/microsoft/apm-action) for automated workflows
 
@@ -87,7 +88,7 @@ pip install apm-cli
 Then start adding packages:
 
 ```bash
-apm install microsoft/apm-sample-package
+apm install microsoft/apm-sample-package#v1.0.0
 ```
 
 See the **[Getting Started guide](https://microsoft.github.io/apm/getting-started/quick-start/)** for the full walkthrough.

{apm_cli-0.7.9 → apm_cli-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.7.9"
+version = "0.8.1"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"

{apm_cli-0.7.9 → apm_cli-0.8.1}/src/apm_cli/adapters/client/base.py

@@ -1,7 +1,10 @@
 """Base adapter interface for MCP clients."""
 
+import re
 from abc import ABC, abstractmethod
 
+_INPUT_VAR_RE = re.compile(r"\$\{input:([^}]+)\}")
+
 
 class MCPClientAdapter(ABC):
     """Base adapter for MCP clients."""
@@ -84,3 +87,33 @@ class MCPClientAdapter(ABC):
             return "nuget"
 
         return ""
+
+    @staticmethod
+    def _warn_input_variables(mapping, server_name, runtime_label):
+        """Emit a warning for each ``${input:...}`` reference found in *mapping*.
+
+        Runtimes that do not support VS Code-style input prompts (Copilot CLI,
+        Codex CLI, etc.) should call this so users know their placeholders
+        will not be resolved at runtime.
+
+        Args:
+            mapping (dict): Header or env dict to scan.
+            server_name (str): Server name for the warning message.
+            runtime_label (str): Human-readable runtime name (e.g. "Copilot CLI").
+        """
+        if not mapping:
+            return
+        seen: set = set()
+        for value in mapping.values():
+            if not isinstance(value, str):
+                continue
+            for match in _INPUT_VAR_RE.finditer(value):
+                var_id = match.group(1)
+                if var_id in seen:
+                    continue
+                seen.add(var_id)
+                print(
+                    f"[!]  Warning: ${{input:{var_id}}} in server "
+                    f"'{server_name}' will not be resolved \u2014 "
+                    f"{runtime_label} does not support input variable prompts"
+                )

{apm_cli-0.7.9 → apm_cli-0.8.1}/src/apm_cli/adapters/client/codex.py

@@ -181,6 +181,7 @@ class CodexClientAdapter(MCPClientAdapter):
             config["args"] = raw["args"]
             if raw.get("env"):
                 config["env"] = raw["env"]
+                self._warn_input_variables(raw["env"], server_info.get("name", ""), "Codex CLI")
             return config
         
         # Note: Remote servers (SSE type) are handled in configure_mcp_server and rejected early
@@ -218,10 +219,24 @@ class CodexClientAdapter(MCPClientAdapter):
                 # Generate command and args based on package type
                 if registry_name == "npm":
                     config["command"] = runtime_hint or "npx"
-                    # Always include package name; filter duplicates from legacy runtime_arguments
                     all_args = processed_runtime_args + processed_package_args
-                    extra_args = [a for a in all_args if a != package_name] if all_args else []
-                    config["args"] = ["-y", package_name] + extra_args
+                    if all_args:
+                        # If runtime_arguments already include the package (bare or
+                        # versioned), use them as-is — they are authoritative from
+                        # the registry and may carry a version pin.
+                        has_pkg = any(
+                            a == package_name or a.startswith(f"{package_name}@")
+                            for a in all_args
+                        )
+                        if has_pkg:
+                            config["args"] = all_args
+                        else:
+                            # Legacy: runtime_arguments don't mention the package,
+                            # prepend -y + bare name ourselves.
+                            extra_args = [a for a in all_args if a != "-y"]
+                            config["args"] = ["-y", package_name] + extra_args
+                    else:
+                        config["args"] = ["-y", package_name]
                     # For NPM packages, also use env block for environment variables
                     if resolved_env:
                         config["env"] = resolved_env

{apm_cli-0.7.9 → apm_cli-0.8.1}/src/apm_cli/adapters/client/copilot.py

@@ -173,6 +173,7 @@ class CopilotClientAdapter(MCPClientAdapter):
             config["args"] = raw["args"]
             if raw.get("env"):
                 config["env"] = raw["env"]
+                self._warn_input_variables(raw["env"], server_info.get("name", ""), "Copilot CLI")
             # Apply tools override if present
             tools_override = server_info.get("_apm_tools_override")
             if tools_override:
@@ -218,6 +219,10 @@ class CopilotClientAdapter(MCPClientAdapter):
                         resolved_value = self._resolve_env_variable(header_name, header_value, env_overrides)
                         config["headers"][header_name] = resolved_value
 
+            # Warn about unresolvable ${input:...} references in headers
+            if config.get("headers"):
+                self._warn_input_variables(config["headers"], server_info.get("name", ""), "Copilot CLI")
+
             # Apply tools override from MCP dependency overlay if present
             tools_override = server_info.get("_apm_tools_override")
             if tools_override:

apm_cli-0.8.1/src/apm_cli/adapters/client/cursor.py

@@ -0,0 +1,138 @@
+"""Cursor IDE implementation of MCP client adapter.
+
+Cursor uses the standard ``mcpServers`` JSON format at ``.cursor/mcp.json``
+(repo-local).  The config schema is identical to GitHub Copilot CLI, so this
+adapter subclasses :class:`CopilotClientAdapter` and only overrides the
+config-path logic and the user-facing labels.
+
+APM only writes to ``.cursor/mcp.json`` when the ``.cursor/`` directory
+already exists — Cursor support is opt-in.
+"""
+
+import json
+import os
+from pathlib import Path
+
+from .copilot import CopilotClientAdapter
+
+
+class CursorClientAdapter(CopilotClientAdapter):
+    """Cursor IDE MCP client adapter.
+
+    Inherits all config formatting from :class:`CopilotClientAdapter`
+    (``mcpServers`` JSON with ``command``/``args``/``env``).  Only the
+    config-file location differs: repo-local ``.cursor/mcp.json`` instead
+    of global ``~/.copilot/mcp-config.json``.
+    """
+
+    # ------------------------------------------------------------------ #
+    # Config path
+    # ------------------------------------------------------------------ #
+
+    def get_config_path(self):
+        """Return the path to ``.cursor/mcp.json`` in the repository root.
+
+        Unlike the Copilot adapter this is a **repo-local** path.  The
+        ``.cursor/`` directory is *not* created automatically — APM only
+        writes here when the directory already exists.
+        """
+        cursor_dir = Path(os.getcwd()) / ".cursor"
+        return str(cursor_dir / "mcp.json")
+
+    # ------------------------------------------------------------------ #
+    # Config read / write — override to avoid auto-creating the directory
+    # ------------------------------------------------------------------ #
+
+    def update_config(self, config_updates):
+        """Merge *config_updates* into the ``mcpServers`` section.
+
+        The ``.cursor/`` directory must already exist; if it does not, this
+        method returns silently (opt-in behaviour).
+        """
+        config_path = Path(self.get_config_path())
+
+        # Opt-in: only write when .cursor/ already exists
+        if not config_path.parent.exists():
+            return
+
+        current_config = self.get_current_config()
+        if "mcpServers" not in current_config:
+            current_config["mcpServers"] = {}
+
+        current_config["mcpServers"].update(config_updates)
+
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(current_config, f, indent=2)
+
+    def get_current_config(self):
+        """Read the current ``.cursor/mcp.json`` contents."""
+        config_path = self.get_config_path()
+
+        if not os.path.exists(config_path):
+            return {}
+
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    # ------------------------------------------------------------------ #
+    # configure_mcp_server — thin override for the print label
+    # ------------------------------------------------------------------ #
+
+    def configure_mcp_server(
+        self,
+        server_url,
+        server_name=None,
+        enabled=True,
+        env_overrides=None,
+        server_info_cache=None,
+        runtime_vars=None,
+    ):
+        """Configure an MCP server in Cursor's ``.cursor/mcp.json``.
+
+        Delegates entirely to the parent implementation but prints a
+        Cursor-specific success message.
+        """
+        if not server_url:
+            print("Error: server_url cannot be empty")
+            return False
+
+        # Opt-in: skip silently when .cursor/ does not exist
+        cursor_dir = Path(os.getcwd()) / ".cursor"
+        if not cursor_dir.exists():
+            return True  # nothing to do, not an error
+
+        try:
+            # Use cached server info if available, otherwise fetch from registry
+            if server_info_cache and server_url in server_info_cache:
+                server_info = server_info_cache[server_url]
+            else:
+                server_info = self.registry_client.find_server_by_reference(server_url)
+
+            if not server_info:
+                print(f"Error: MCP server '{server_url}' not found in registry")
+                return False
+
+            # Determine config key
+            if server_name:
+                config_key = server_name
+            elif "/" in server_url:
+                config_key = server_url.split("/")[-1]
+            else:
+                config_key = server_url
+
+            server_config = self._format_server_config(
+                server_info, env_overrides, runtime_vars
+            )
+            self.update_config({config_key: server_config})
+
+            print(
+                f"Successfully configured MCP server '{config_key}' for Cursor"
+            )
+            return True
+
+        except Exception as e:
+            print(f"Error configuring MCP server: {e}")
+            return False

apm_cli-0.8.1/src/apm_cli/adapters/client/opencode.py

@@ -0,0 +1,157 @@
+"""OpenCode implementation of MCP client adapter.
+
+OpenCode uses ``opencode.json`` at the project root with an ``mcp`` key.
+The schema differs from VSCode/Cursor:
+
+.. code-block:: json
+
+   {
+     "mcp": {
+       "server-name": {
+         "type": "local",
+         "command": ["npx", "-y", "@modelcontextprotocol/server-foo"],
+         "environment": { "KEY": "value" },
+         "enabled": true
+       }
+     }
+   }
+
+Key differences from Copilot/Cursor:
+- Config file: ``opencode.json`` (not ``mcp.json``)
+- Wrapper key: ``mcp`` (not ``mcpServers``)
+- Command format: single array ``command`` (not ``command`` + ``args``)
+- Env key: ``environment`` (not ``env``)
+
+APM only writes to ``opencode.json`` when the ``.opencode/`` directory
+already exists — OpenCode support is opt-in.
+"""
+
+import json
+import os
+from pathlib import Path
+
+from .copilot import CopilotClientAdapter
+
+
+class OpenCodeClientAdapter(CopilotClientAdapter):
+    """OpenCode MCP client adapter.
+
+    Converts the standard Copilot config format into OpenCode's schema
+    and writes to ``opencode.json`` in the project root.
+    """
+
+    def get_config_path(self):
+        """Return the path to ``opencode.json`` in the repository root."""
+        return str(Path(os.getcwd()) / "opencode.json")
+
+    def update_config(self, config_updates, enabled=True):
+        """Merge *config_updates* into the ``mcp`` section of ``opencode.json``.
+
+        The ``.opencode/`` directory must already exist; if it does not, this
+        method returns silently (opt-in behaviour).
+
+        Translates Copilot-format entries (``command``/``args``/``env``) into
+        OpenCode format (``command`` array / ``environment``).
+        """
+        opencode_dir = Path(os.getcwd()) / ".opencode"
+        if not opencode_dir.is_dir():
+            return
+
+        config_path = Path(self.get_config_path())
+        current_config = self.get_current_config()
+        if "mcp" not in current_config:
+            current_config["mcp"] = {}
+
+        for name, copilot_entry in config_updates.items():
+            current_config["mcp"][name] = self._to_opencode_format(copilot_entry, enabled=enabled)
+
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(current_config, f, indent=2)
+
+    def get_current_config(self):
+        """Read the current ``opencode.json`` contents."""
+        config_path = self.get_config_path()
+        if not os.path.exists(config_path):
+            return {}
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def configure_mcp_server(
+        self,
+        server_url,
+        server_name=None,
+        enabled=True,
+        env_overrides=None,
+        server_info_cache=None,
+        runtime_vars=None,
+    ):
+        """Configure an MCP server in ``opencode.json``.
+
+        Delegates to the parent for config formatting, then converts to
+        OpenCode schema before writing.
+        """
+        if not server_url:
+            print("Error: server_url cannot be empty")
+            return False
+
+        opencode_dir = Path(os.getcwd()) / ".opencode"
+        if not opencode_dir.is_dir():
+            return False
+
+        try:
+            if server_info_cache and server_url in server_info_cache:
+                server_info = server_info_cache[server_url]
+            else:
+                server_info = self.registry_client.find_server_by_reference(server_url)
+
+            if not server_info:
+                print(f"Error: MCP server '{server_url}' not found in registry")
+                return False
+
+            if server_name:
+                config_key = server_name
+            elif "/" in server_url:
+                config_key = server_url.split("/")[-1]
+            else:
+                config_key = server_url
+
+            server_config = self._format_server_config(
+                server_info, env_overrides, runtime_vars
+            )
+            self.update_config({config_key: server_config}, enabled=enabled)
+
+            print(
+                f"Successfully configured MCP server '{config_key}' for OpenCode"
+            )
+            return True
+
+        except Exception as e:
+            print(f"Error configuring MCP server: {e}")
+            return False
+
+    @staticmethod
+    def _to_opencode_format(copilot_entry: dict, enabled: bool = True) -> dict:
+        """Convert a Copilot-format server config to OpenCode format.
+
+        Copilot: ``{"command": "npx", "args": ["-y", "pkg"], "env": {...}}``
+        OpenCode: ``{"type": "local", "command": ["npx", "-y", "pkg"],
+                     "environment": {...}, "enabled": true}``
+        """
+        entry: dict = {"type": "local", "enabled": enabled}
+
+        cmd = copilot_entry.get("command", "")
+        args = copilot_entry.get("args", [])
+        if cmd:
+            entry["command"] = [cmd] + list(args)
+        elif "url" in copilot_entry:
+            entry["type"] = "remote"
+            entry["url"] = copilot_entry["url"]
+
+        env = copilot_entry.get("env") or {}
+        if env:
+            entry["environment"] = env
+
+        return entry

{apm_cli-0.7.9 → apm_cli-0.8.1}/src/apm_cli/adapters/client/vscode.py

@@ -8,7 +8,7 @@ https://code.visualstudio.com/docs/copilot/chat/mcp-servers
 import json
 import os
 from pathlib import Path
-from .base import MCPClientAdapter
+from .base import MCPClientAdapter, _INPUT_VAR_RE
 from ...registry.client import SimpleRegistryClient
 from ...registry.integration import RegistryIntegration
 
@@ -197,6 +197,9 @@ class VSCodeClientAdapter(MCPClientAdapter):
             }
             if raw.get("env"):
                 server_config["env"] = raw["env"]
+                input_vars.extend(
+                    self._extract_input_variables(raw["env"], server_info.get("name", ""))
+                )
             return server_config, input_vars
         
         # Check for packages information
@@ -308,6 +311,9 @@ class VSCodeClientAdapter(MCPClientAdapter):
                         "url": remote.get("url", ""),
                         "headers": headers,
                     }
+                    input_vars.extend(
+                        self._extract_input_variables(headers, server_info.get("name", ""))
+                    )
             # If no packages AND no endpoints/remotes, fail with clear error
             else:
                 packages = server_info.get("packages", [])
@@ -323,6 +329,36 @@ class VSCodeClientAdapter(MCPClientAdapter):
         
         return server_config, input_vars
 
+    def _extract_input_variables(self, mapping, server_name):
+        """Scan dict values for ${input:...} references and return input variable definitions.
+
+        Args:
+            mapping (dict): Header or env dict whose values may contain
+                ``${input:<id>}`` placeholders.
+            server_name (str): Server name used in the description field.
+
+        Returns:
+            list[dict]: Input variable definitions (``promptString``, ``password: true``).
+                Duplicates within *mapping* are already deduplicated.
+        """
+        seen: set = set()
+        result: list = []
+        for value in (mapping or {}).values():
+            if not isinstance(value, str):
+                continue
+            for match in _INPUT_VAR_RE.finditer(value):
+                var_id = match.group(1)
+                if var_id in seen:
+                    continue
+                seen.add(var_id)
+                result.append({
+                    "type": "promptString",
+                    "id": var_id,
+                    "description": f"{var_id} for MCP server {server_name}",
+                    "password": True,
+                })
+        return result
+
     @staticmethod
     def _extract_package_args(package):
         """Extract positional arguments from a package entry.

{apm_cli-0.7.9 → apm_cli-0.8.1}/src/apm_cli/bundle/packer.py

@@ -1,5 +1,6 @@
 """Bundle packer  -- creates self-contained APM bundles from the resolved dependency tree."""
 
+import os
 import shutil
 import tarfile
 from dataclasses import dataclass, field
@@ -17,7 +18,9 @@ _TARGET_PREFIXES = {
     "copilot": [".github/"],
     "vscode": [".github/"],
     "claude": [".claude/"],
-    "all": [".github/", ".claude/"],
+    "cursor": [".cursor/"],
+    "opencode": [".opencode/"],
+    "all": [".github/", ".claude/", ".cursor/", ".opencode/"],
 }
 
 
@@ -153,6 +156,35 @@ def pack_bundle(
             lockfile_enriched=True,
         )
 
+    # 5b. Scan files for hidden characters before bundling.
+    # Intentionally non-blocking (warn only) — pack is an authoring tool.
+    # Critical findings here mean the author's own source files contain
+    # hidden characters. We surface them so the author can fix before
+    # publishing, but don't block the bundle. Consumers are protected by
+    # install/unpack which block on critical.
+    from ..security.gate import WARN_POLICY, SecurityGate
+    from ..utils.console import _rich_warning
+
+    _scan_findings_total = 0
+    for rel_path in unique_files:
+        src = project_root / rel_path
+        if src.is_symlink():
+            continue
+        if src.is_dir():
+            verdict = SecurityGate.scan_files(src, policy=WARN_POLICY)
+            _scan_findings_total += len(verdict.all_findings)
+        elif src.is_file():
+            verdict = SecurityGate.scan_text(
+                src.read_text(encoding="utf-8", errors="replace"),
+                str(src), policy=WARN_POLICY,
+            )
+            _scan_findings_total += len(verdict.all_findings)
+    if _scan_findings_total:
+        _rich_warning(
+            f"Bundle contains {_scan_findings_total} hidden character(s) across source files "
+            f"— run 'apm audit' to inspect before publishing"
+        )
+
     # 6. Build output directory
     bundle_dir = output_dir / f"{pkg_name}-{pkg_version}"
     bundle_dir.mkdir(parents=True, exist_ok=True)
@@ -160,12 +192,15 @@ def pack_bundle(
     # 7. Copy files preserving directory structure
     for rel_path in unique_files:
         src = project_root / rel_path
+        if src.is_symlink():
+            continue  # Never bundle symlinks
         dest = bundle_dir / rel_path
         if src.is_dir():
-            shutil.copytree(src, dest, dirs_exist_ok=True)
+            from ..security.gate import ignore_symlinks
+            shutil.copytree(src, dest, dirs_exist_ok=True, ignore=ignore_symlinks)
         else:
             dest.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(src, dest)
+            shutil.copy2(src, dest, follow_symlinks=False)
 
     # 8. Enrich lockfile copy and write to bundle
     enriched_yaml = enrich_lockfile_for_pack(lockfile, fmt, effective_target)