agentnet-cli 0.1.0__py3-none-any.whl

agentnet_cli/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("agentnet-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

agentnet_cli/agents/README.md

@@ -0,0 +1,55 @@
+# Agent Connectors
+
+Each file in this directory implements integration with one AI coding agent. All connectors implement the `AgentConnector` ABC from `base.py`.
+
+## Connector Interface
+
+```python
+class AgentConnector(ABC):
+    def detect(self) -> DetectionResult
+    def connect(self, platform_config: dict) -> ConnectionResult
+    def disconnect(self, connection_manifest: dict) -> bool
+```
+
+**detect()** — Check if the agent is installed by looking for its config directory and validation files.
+
+**connect()** — Inject three layers:
+1. MCP server config (so the agent can call Agent-net tools)
+2. Context/skill files (so the LLM knows how to use the tools)
+3. Permission rules (so tool calls don't require manual approval)
+
+**disconnect()** — Remove everything `connect()` wrote, using the manifest to know exactly what to clean up.
+
+## Adding a New Connector
+
+1. Create `agents/<name>.py` implementing `AgentConnector`
+2. Add the agent to `paths.py`:
+   - Add to `AgentName(StrEnum)`
+   - Add to `_AGENT_DOT_DIRS` mapping
+3. Create shim templates in `shims/<name>/`
+4. Wire into `registry.py` `_CONNECTORS` dict
+5. Add tests in `tests/test_<name>.py`
+
+## Current Connectors
+
+| File | Agent | MCP Config Path | Key Files Injected |
+|------|-------|----------------|-------------------|
+| `claude.py` | Claude Code | `~/.claude.json` | `skills/agentnet/SKILL.md`, `settings.json` perms |
+| `cursor.py` | Cursor | `~/.cursor/mcp.json` | `rules/agentnet.mdc`, `agents/agentnet.md` |
+| `copilot.py` | GitHub Copilot | `~/.copilot/mcp-config.json` | `agents/agentnet.agent.md` |
+| `codex.py` | OpenAI Codex | `~/.codex/config.toml` | `skills/agentnet/SKILL.md` |
+| `hermes.py` | Hermes (Nous) | `~/.hermes/config.yaml` | YAML merge under `mcp.servers` |
+| `openclaw.py` | OpenClaw | `~/.openclaw/openclaw.json` | Plugin entry in `plugins` |
+
+## Path Resolution
+
+All connectors use `agent_config_root()` and `agentnet_home()` from `paths.py` — never `Path.home()` directly. This ensures tests can monkeypatch the home directory.
+
+## Config Merging
+
+When writing MCP configs, connectors merge into existing files (never overwrite):
+- **JSON**: Read, deep-merge the `mcpServers.agentnet` key, write back
+- **TOML**: Append `[mcp_servers.agentnet]` section if not present
+- **YAML**: Read, merge under `mcp.servers.agentnet`, write back
+
+Original files are backed up to `~/.agentnet/backups/<agent>/` before modification.

agentnet_cli/agents/base.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class DetectionResult:
+    agent_name: str
+    detected: bool
+    config_root: Path | None = None
+    binary_path: Path | None = None
+    binary_found: bool = False
+    version: str | None = None
+    already_connected: bool = False
+
+
+@dataclass
+class ConnectionResult:
+    success: bool
+    files_created: list[Path] = field(default_factory=list)
+    files_modified: list[tuple[Path, Path]] = field(default_factory=list)
+    mcp_entry: dict[str, Any] = field(default_factory=dict)
+    errors: list[str] = field(default_factory=list)
+
+
+class AgentConnector(ABC):
+    @abstractmethod
+    def detect(self) -> DetectionResult: ...
+
+    @abstractmethod
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult: ...
+
+    @abstractmethod
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool: ...

agentnet_cli/agents/claude.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from ..paths import AgentName, agent_config_root
+from .base import AgentConnector, ConnectionResult, DetectionResult
+
+_GITHUB_MARKETPLACE = "TheAgent-net/agentnet-cli"
+_PLUGIN_ID = "agentnet@agentnet-cli"
+_SUBPROCESS_TIMEOUT = 120
+
+
+def _find_marketplace_source() -> str:
+    local = Path(__file__).resolve().parent.parent.parent.parent
+    if (local / ".claude-plugin" / "marketplace.json").exists():
+        return str(local)
+    return _GITHUB_MARKETPLACE
+
+
+class ClaudeConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.CLAUDE)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.CLAUDE, detected=False)
+        for vf in ["settings.json"]:
+            if (root / vf).exists():
+                return DetectionResult(agent_name=AgentName.CLAUDE, detected=True, config_root=root)
+        claude_json = root.parent / ".claude.json"
+        if claude_json.exists():
+            return DetectionResult(agent_name=AgentName.CLAUDE, detected=True, config_root=root)
+        return DetectionResult(agent_name=AgentName.CLAUDE, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        claude_bin = shutil.which("claude")
+        if not claude_bin:
+            return ConnectionResult(
+                success=False,
+                errors=["Claude Code not found. Install it from https://code.claude.com"],
+            )
+
+        marketplace_src = _find_marketplace_source()
+
+        proc = subprocess.run(
+            ["claude", "plugin", "marketplace", "add", marketplace_src, "--scope", "user"],
+            capture_output=True,
+            timeout=_SUBPROCESS_TIMEOUT,
+        )
+        if proc.returncode != 0:
+            msg = proc.stderr.decode(errors="replace").strip()
+            return ConnectionResult(success=False, errors=[f"marketplace add failed: {msg}"])
+
+        proc = subprocess.run(
+            ["claude", "plugin", "install", _PLUGIN_ID, "--scope", "user"],
+            capture_output=True,
+            timeout=_SUBPROCESS_TIMEOUT,
+        )
+        if proc.returncode != 0:
+            msg = proc.stderr.decode(errors="replace").strip()
+            return ConnectionResult(success=False, errors=[f"plugin install failed: {msg}"])
+
+        self._cleanup_legacy()
+
+        return ConnectionResult(
+            success=True,
+            mcp_entry={"scope": "plugin", "plugin_name": _PLUGIN_ID},
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        claude_bin = shutil.which("claude")
+        if not claude_bin:
+            return True
+
+        subprocess.run(
+            ["claude", "plugin", "uninstall", _PLUGIN_ID, "--scope", "user", "-y"],
+            capture_output=True,
+            timeout=_SUBPROCESS_TIMEOUT,
+        )
+        return True
+
+    @staticmethod
+    def _cleanup_legacy() -> None:
+        root = agent_config_root(AgentName.CLAUDE)
+
+        skill_path = root / "skills" / "agentnet" / "SKILL.md"
+        if skill_path.exists():
+            skill_path.unlink()
+            skill_dir = skill_path.parent
+            if skill_dir.exists() and not any(skill_dir.iterdir()):
+                skill_dir.rmdir()
+
+        claude_json = root.parent / ".claude.json"
+        if claude_json.exists():
+            try:
+                data = json.loads(claude_json.read_text())
+                if "agentnet" in data.get("mcpServers", {}):
+                    data["mcpServers"].pop("agentnet")
+                    claude_json.write_text(json.dumps(data, indent=2) + "\n")
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        settings_path = root / "settings.json"
+        if settings_path.exists():
+            try:
+                data = json.loads(settings_path.read_text())
+                allow = data.get("permissions", {}).get("allow", [])
+                if "mcp__agentnet__*" in allow:
+                    allow.remove("mcp__agentnet__*")
+                    settings_path.write_text(json.dumps(data, indent=2) + "\n")
+            except (json.JSONDecodeError, OSError):
+                pass

agentnet_cli/agents/codex.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import shutil
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+from ..paths import AgentName, agent_config_root
+from .base import AgentConnector, ConnectionResult, DetectionResult
+from .shims import load_shim
+
+
+class CodexConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.CODEX)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.CODEX, detected=False)
+        for vf in ["config.toml", "auth.json"]:
+            if (root / vf).exists():
+                return DetectionResult(agent_name=AgentName.CODEX, detected=True, config_root=root)
+        return DetectionResult(agent_name=AgentName.CODEX, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        files_created: list[Path] = []
+        root = agent_config_root(AgentName.CODEX)
+        root.mkdir(parents=True, exist_ok=True)
+
+        toml_path = root / "config.toml"
+        data: dict[str, Any] = {}
+        if toml_path.exists():
+            data = tomllib.loads(toml_path.read_text())
+
+        agentnet_bin = shutil.which("agentnet")
+        if agentnet_bin:
+            command = agentnet_bin
+        else:
+            command = "uvx"
+
+        mcp_servers = data.setdefault("mcp_servers", {})
+        if command == "uvx":
+            mcp_servers["agentnet"] = {
+                "command": command,
+                "args": ["agentnet-cli", "mcp-serve"],
+                "env": {"AGENTNET_TOKEN": "${AGENTNET_TOKEN}"},
+            }
+        else:
+            mcp_servers["agentnet"] = {
+                "command": command,
+                "args": ["mcp-serve"],
+            }
+        toml_path.write_text(tomli_w.dumps(data))
+
+        skill_dir = root / "skills" / "agentnet"
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        skill_path = skill_dir / "SKILL.md"
+        skill_path.write_text(load_shim("codex/skill.md"))
+        files_created.append(skill_path)
+        return ConnectionResult(
+            success=True, files_created=files_created,
+            mcp_entry={"scope": "user", "file": str(toml_path), "server_name": "agentnet"},
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        for path_str in connection_manifest.get("files_created", []):
+            p = Path(path_str)
+            if p.exists():
+                p.unlink()
+        mcp_info = connection_manifest.get("mcp_registered", {})
+        mcp_file = mcp_info.get("file")
+        if mcp_file:
+            toml_path = Path(mcp_file)
+            if toml_path.exists():
+                data = tomllib.loads(toml_path.read_text())
+                data.get("mcp_servers", {}).pop("agentnet", None)
+                toml_path.write_text(tomli_w.dumps(data))
+        return True

agentnet_cli/agents/copilot.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ..paths import AgentName, agent_config_root
+from .base import AgentConnector, ConnectionResult, DetectionResult
+from .shims import load_shim
+
+
+class CopilotConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.COPILOT)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.COPILOT, detected=False)
+        if any((root / vf).exists() for vf in ["settings.json", "config.json", "mcp-config.json", "ide"]):
+            return DetectionResult(agent_name=AgentName.COPILOT, detected=True, config_root=root)
+        return DetectionResult(agent_name=AgentName.COPILOT, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        files_created: list[Path] = []
+
+        root = agent_config_root(AgentName.COPILOT)
+        root.mkdir(parents=True, exist_ok=True)
+
+        dot_mcp = root / "mcp-config.json"
+        mcp_entry_info = self._merge_mcp(dot_mcp, self._build_mcp_entry())
+
+        agents_dir = root / "agents"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        agent_path = agents_dir / "agentnet.agent.md"
+        agent_path.write_text(load_shim("copilot/agentnet.agent.md"))
+        files_created.append(agent_path)
+
+        return ConnectionResult(
+            success=True,
+            files_created=files_created,
+            mcp_entry=mcp_entry_info,
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        deleted: list[Path] = []
+        for path_str in connection_manifest.get("files_created", []):
+            p = Path(path_str)
+            if p.exists():
+                p.unlink()
+                deleted.append(p)
+
+        # Clean empty parent dirs (e.g. agents/)
+        for p in deleted:
+            if p.parent.exists() and not any(p.parent.iterdir()):
+                p.parent.rmdir()
+
+        mcp_info = connection_manifest.get("mcp_registered", {})
+        mcp_file = mcp_info.get("file")
+        if mcp_file:
+            mcp_path = Path(mcp_file)
+            if mcp_path.exists():
+                data = json.loads(mcp_path.read_text())
+                data.get("mcpServers", {}).pop("agentnet", None)
+                mcp_path.write_text(json.dumps(data, indent=2) + "\n")
+
+        return True
+
+    def _build_mcp_entry(self) -> dict[str, Any]:
+        agentnet_bin = shutil.which("agentnet")
+        if agentnet_bin:
+            return {
+                "type": "stdio",
+                "command": agentnet_bin,
+                "args": ["mcp-serve"],
+            }
+        return {
+            "type": "stdio",
+            "command": "uvx",
+            "args": ["agentnet-cli", "mcp-serve"],
+        }
+
+    def _merge_mcp(self, mcp_path: Path, entry: dict[str, Any]) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        if mcp_path.exists():
+            data = json.loads(mcp_path.read_text())
+        data.setdefault("mcpServers", {})
+        data["mcpServers"]["agentnet"] = entry
+        mcp_path.parent.mkdir(parents=True, exist_ok=True)
+        mcp_path.write_text(json.dumps(data, indent=2) + "\n")
+        return {"scope": "user", "file": str(mcp_path), "server_name": "agentnet"}

agentnet_cli/agents/cursor.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ..paths import AgentName, agent_config_root
+from .base import AgentConnector, ConnectionResult, DetectionResult
+from .shims import load_shim
+
+
+class CursorConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.CURSOR)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.CURSOR, detected=False)
+        for vf in ["extensions", "mcp.json", "cli-config.json"]:
+            if (root / vf).exists():
+                return DetectionResult(agent_name=AgentName.CURSOR, detected=True, config_root=root)
+        return DetectionResult(agent_name=AgentName.CURSOR, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        files_created: list[Path] = []
+        root = agent_config_root(AgentName.CURSOR)
+
+        # Layer 1: MCP
+        mcp_path = root / "mcp.json"
+        mcp_entry = self._write_mcp(mcp_path)
+
+        # Layer 2a: Rule
+        rules_dir = root / "rules"
+        rules_dir.mkdir(parents=True, exist_ok=True)
+        mdc_path = rules_dir / "agentnet.mdc"
+        mdc_path.write_text(load_shim("cursor/agentnet.mdc"))
+        files_created.append(mdc_path)
+
+        # Layer 2b: Subagent
+        agents_dir = root / "agents"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        agent_path = agents_dir / "agentnet.md"
+        agent_path.write_text(load_shim("cursor/agent.md"))
+        files_created.append(agent_path)
+
+        return ConnectionResult(
+            success=True, files_created=files_created, mcp_entry=mcp_entry,
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        deleted: list[Path] = []
+        for path_str in connection_manifest.get("files_created", []):
+            p = Path(path_str)
+            if p.exists():
+                p.unlink()
+                deleted.append(p)
+
+        # Clean empty parent dirs (e.g. rules/, agents/)
+        for p in deleted:
+            if p.parent.exists() and not any(p.parent.iterdir()):
+                p.parent.rmdir()
+
+        mcp_info = connection_manifest.get("mcp_registered", {})
+        mcp_file = mcp_info.get("file")
+        if mcp_file:
+            mcp_path = Path(mcp_file)
+            if mcp_path.exists():
+                data = json.loads(mcp_path.read_text())
+                data.get("mcpServers", {}).pop("agentnet", None)
+                mcp_path.write_text(json.dumps(data, indent=2) + "\n")
+        return True
+
+    def _write_mcp(self, mcp_path: Path) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        if mcp_path.exists():
+            data = json.loads(mcp_path.read_text())
+        data.setdefault("mcpServers", {})
+
+        agentnet_bin = shutil.which("agentnet")
+        if agentnet_bin:
+            command, args = agentnet_bin, ["mcp-serve"]
+        else:
+            command, args = "uvx", ["agentnet-cli", "mcp-serve"]
+
+        data["mcpServers"]["agentnet"] = {
+            "command": command,
+            "args": args,
+            "env": {"AGENTNET_TOKEN": "${env:AGENTNET_TOKEN}"},
+        }
+        mcp_path.write_text(json.dumps(data, indent=2) + "\n")
+        return {"scope": "global", "file": str(mcp_path), "server_name": "agentnet"}

agentnet_cli/agents/hermes.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from ..paths import AgentName, agent_config_root
+from .base import AgentConnector, ConnectionResult, DetectionResult
+
+_PLUGIN_NAME = "agentnet"
+
+
+def _hermes_plugin_source() -> Path:
+    from ..hermes_plugin import _PLUGIN_DIR  # noqa: PLC0415
+
+    return _PLUGIN_DIR
+
+
+def _find_hermes_venv(root: Path) -> Path | None:
+    candidates = [
+        root / "hermes-agent" / "venv",
+        root / "venv",
+    ]
+    for venv in candidates:
+        if (venv / "bin" / "python").exists() or (venv / "Scripts" / "python.exe").exists():
+            return venv
+    return None
+
+
+def _install_into_hermes_venv(venv: Path) -> bool:
+    python = venv / "bin" / "python"
+    if not python.exists():
+        python = venv / "Scripts" / "python.exe"
+    if not python.exists():
+        return False
+
+    try:
+        if shutil.which("uv"):
+            subprocess.run(
+                ["uv", "pip", "install", "agentnet-cli", "--python", str(python)],
+                capture_output=True,
+                timeout=120,
+            )
+        else:
+            subprocess.run(
+                [str(python), "-m", "pip", "install", "agentnet-cli"],
+                capture_output=True,
+                timeout=120,
+            )
+        return True
+    except Exception:
+        return False
+
+
+class HermesConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.HERMES)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.HERMES, detected=False)
+        if (root / "config.yaml").exists():
+            return DetectionResult(
+                agent_name=AgentName.HERMES,
+                detected=True,
+                config_root=root,
+            )
+        return DetectionResult(agent_name=AgentName.HERMES, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        root = agent_config_root(AgentName.HERMES)
+        config_path = root / "config.yaml"
+        plugin_dir = root / "plugins" / _PLUGIN_NAME
+
+        hermes_venv = _find_hermes_venv(root)
+        if hermes_venv:
+            _install_into_hermes_venv(hermes_venv)
+
+        source = _hermes_plugin_source()
+        if plugin_dir.exists():
+            shutil.rmtree(plugin_dir)
+        shutil.copytree(source, plugin_dir)
+
+        for cache_dir in plugin_dir.rglob("__pycache__"):
+            shutil.rmtree(cache_dir)
+
+        skill_src = source / "skills" / _PLUGIN_NAME
+        skill_dst = root / "skills" / _PLUGIN_NAME
+        if skill_src.is_dir():
+            if skill_dst.exists():
+                shutil.rmtree(skill_dst)
+            shutil.copytree(skill_src, skill_dst)
+
+        files_created = [f for f in plugin_dir.rglob("*") if f.is_file()]
+        if skill_dst.exists():
+            files_created.extend(f for f in skill_dst.rglob("*") if f.is_file())
+
+        data: dict[str, Any] = {}
+        if config_path.exists():
+            data = yaml.safe_load(config_path.read_text()) or {}
+
+        plugins = data.setdefault("plugins", {})
+        enabled = plugins.setdefault("enabled", [])
+        if _PLUGIN_NAME not in enabled:
+            enabled.append(_PLUGIN_NAME)
+
+        self._cleanup_legacy(data, root)
+
+        config_path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False))
+
+        return ConnectionResult(
+            success=True,
+            files_created=files_created,
+            mcp_entry={
+                "scope": "plugin",
+                "plugin_dir": str(plugin_dir),
+            },
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        root = agent_config_root(AgentName.HERMES)
+        config_path = root / "config.yaml"
+
+        mcp_info = connection_manifest.get("mcp_registered", {})
+        plugin_dir_str = mcp_info.get("plugin_dir")
+        if plugin_dir_str:
+            plugin_dir = Path(plugin_dir_str)
+        else:
+            plugin_dir = root / "plugins" / _PLUGIN_NAME
+
+        if plugin_dir.exists():
+            shutil.rmtree(plugin_dir)
+
+        skill_dir = root / "skills" / _PLUGIN_NAME
+        if skill_dir.exists():
+            shutil.rmtree(skill_dir)
+
+        if config_path.exists():
+            data = yaml.safe_load(config_path.read_text()) or {}
+            plugins = data.get("plugins", {})
+            if isinstance(plugins, dict):
+                enabled = plugins.get("enabled", [])
+                if isinstance(enabled, list) and _PLUGIN_NAME in enabled:
+                    enabled.remove(_PLUGIN_NAME)
+            self._cleanup_legacy(data, root)
+            config_path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False))
+
+        return True
+
+    @staticmethod
+    def _cleanup_legacy(data: dict[str, Any], root: Path) -> None:
+        mcp_servers = data.get("mcp_servers", {})
+        if isinstance(mcp_servers, dict):
+            mcp_servers.pop("agentnet", None)
+
+        old_mcp = data.get("mcp", {})
+        if isinstance(old_mcp, dict):
+            old_servers = old_mcp.get("servers", {})
+            if isinstance(old_servers, dict):
+                old_servers.pop("agentnet", None)
+
+        platform_toolsets = data.get("platform_toolsets", {})
+        if isinstance(platform_toolsets, dict):
+            for toolsets in platform_toolsets.values():
+                if isinstance(toolsets, list) and "mcp-agentnet" in toolsets:
+                    toolsets.remove("mcp-agentnet")
+
+        top_toolsets = data.get("toolsets")
+        if isinstance(top_toolsets, list) and "mcp-agentnet" in top_toolsets:
+            top_toolsets.remove("mcp-agentnet")