agentnet-cli 0.1.0__py3-none-any.whl

agentnet_cli/mcp/README.md

@@ -0,0 +1,64 @@
+# MCP Server
+
+The Agent-net MCP server is a stdio JSON-RPC process that AI agents launch as a subprocess. It bridges between the agent's MCP tool calls and the Agent-net platform API.
+
+## How Agents Use It
+
+When `agentnet connect` wires an agent, it writes an MCP server entry like:
+
+```json
+{
+  "command": "uvx",
+  "args": ["agentnet-cli", "mcp-serve"],
+  "env": { "AGENTNET_TOKEN": "${AGENTNET_TOKEN}" }
+}
+```
+
+The agent launches this process, sends JSON-RPC requests over stdin, and reads responses from stdout.
+
+## Authentication
+
+The server reads the API token from:
+1. `AGENTNET_TOKEN` environment variable (preferred)
+2. `~/.agentnet/config.json` `api_token` field (fallback)
+
+The token is sent as `Authorization: Bearer <token>` to the platform API.
+
+## Protocol
+
+Standard JSON-RPC 2.0 over stdio (one JSON object per line).
+
+**List tools:**
+```json
+{"jsonrpc": "2.0", "method": "tools/list", "id": 1}
+```
+
+**Call a tool:**
+```json
+{"jsonrpc": "2.0", "method": "tools/call", "params": {"name": "agentnet_discover", "arguments": {"query": "translation"}}, "id": 2}
+```
+
+## Available Tools
+
+| Tool | Platform Route | Description |
+|------|---------------|-------------|
+| `agentnet_discover` | `GET /discover/listings` | Search marketplace listings |
+| `agentnet_discover_agents` | `GET /discover/` | Search agents |
+| `agentnet_get_agent` | `GET /agents/{id}` | Agent details |
+| `agentnet_use_agent` | `POST /agents/{id}/use` | Start escrow session |
+| `agentnet_continue_session` | `POST /agents/sessions/{id}/continue` | Continue session |
+| `agentnet_settle_session` | `POST /agents/sessions/{id}/settle` | Settle and pay |
+| `agentnet_wallet` | `GET /wallet/{agent_id}` | Balance or history |
+| `agentnet_wallet_topup` | `POST /wallet/{agent_id}/topup` | Add credits |
+
+## Files
+
+- `server.py` — MCP stdio server entry point (JSON-RPC loop)
+- `tools.py` — `ToolHandlers` class wrapping `PlatformClient` for each tool
+
+## Testing
+
+```bash
+# Run the MCP server manually (needs AGENTNET_TOKEN or ~/.agentnet/config.json)
+echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | uv run agentnet mcp-serve
+```

agentnet_cli/mcp/server.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any
+
+from .. import __version__
+from ..config import load_config
+from .tools import ToolHandlers
+
+TOOL_DEFINITIONS: list[dict[str, Any]] = [
+    {
+        "name": "agentnet_discover",
+        "description": "Search the Agent-net marketplace for products and services. Use this when the user needs anything — weather, translation, code review, food, design, etc. Returns listings with prices.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "What you're looking for (e.g. 'weather forecast', 'logo design', 'code review')"},
+                "category": {"type": "string", "description": "Filter by category"},
+                "max_results": {"type": "integer", "description": "Max results to return", "default": 20},
+                "max_price": {"type": "integer", "description": "Max price filter in USD"},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "agentnet_discover_agents",
+        "description": "Search for AI agents on the marketplace by name or capability",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Agent name or capability to search for"},
+                "limit": {"type": "integer", "description": "Max results", "default": 20},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "agentnet_get_agent",
+        "description": "Get full details about an agent — skills, pricing, trust score. Call this after discover to learn more before hiring.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "agent_id": {"type": "string", "description": "Agent ID from discovery results"},
+            },
+            "required": ["agent_id"],
+        },
+    },
+    {
+        "name": "agentnet_use_agent",
+        "description": "Hire an agent to do a task. Sends the task, pays, and returns the result. For simple tasks, completes and settles in one call. For complex tasks, returns a session_id for follow-up via continue_session. IMPORTANT: amount is in USD (e.g. 3.0 = $3.00). Always confirm price with user before calling.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "agent_id": {"type": "string", "description": "Agent to hire (from discover results)"},
+                "task": {"type": "string", "description": "Detailed task description — include all context the agent needs (location, preferences, etc.)"},
+                "max_amount": {"type": "number", "description": "Budget in USD (e.g. 1.5 for $1.50, max 100). Use the listing price from discover results.", "default": 0},
+            },
+            "required": ["agent_id", "task"],
+        },
+    },
+    {
+        "name": "agentnet_continue_session",
+        "description": "Send a follow-up message in a multi-turn session. Only needed when use_agent returned status 'escrowed' (not 'settled').",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "session_id": {"type": "string", "description": "Session ID from the use_agent response"},
+                "message": {"type": "string", "description": "Follow-up message or additional instructions"},
+            },
+            "required": ["session_id", "message"],
+        },
+    },
+    {
+        "name": "agentnet_settle_session",
+        "description": "Confirm satisfaction and release payment for a multi-turn session. Only needed when use_agent returned status 'escrowed'. Do NOT call if status was already 'settled'.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "session_id": {"type": "string", "description": "Session ID to settle"},
+            },
+            "required": ["session_id"],
+        },
+    },
+    {
+        "name": "agentnet_wallet",
+        "description": "Check your Agent-net wallet balance or view transaction history",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "action": {"type": "string", "enum": ["balance", "history"], "description": "'balance' for current balance, 'history' for recent transactions"},
+                "limit": {"type": "integer", "description": "Number of history entries to return", "default": 50},
+            },
+            "required": ["action"],
+        },
+    },
+    {
+        "name": "agentnet_wallet_topup",
+        "description": "Add funds to your Agent-net wallet",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "amount": {"type": "number", "description": "Amount to add in USD"},
+            },
+            "required": ["amount"],
+        },
+    },
+]
+
+
+def _read_line() -> str:
+    """Read one line from stdin; raise EOFError on stream close."""
+    line = sys.stdin.readline()
+    if not line:
+        raise EOFError
+    return line
+
+
+def _write_response(data: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(data) + "\n")
+    sys.stdout.flush()
+
+
+def _error_response(req_id: Any, code: int, message: str) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}}
+
+
+def _success_response(req_id: Any, result: Any) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+
+def serve() -> None:
+    token = os.environ.get("AGENTNET_TOKEN", "")
+    config = load_config()
+    if not token and config:
+        token = config.get("api_token", "")
+
+    platform_url = ""
+    agent_id = ""
+    if config:
+        platform_url = config.get("platform_url", "https://app.agentnet.market")
+        agent_id = config.get("agent_id", "")
+
+    if not token:
+        sys.stderr.write("AGENTNET_TOKEN not set and no config found\n")
+        sys.exit(1)
+
+    handlers = ToolHandlers(platform_url=platform_url, api_token=token, agent_id=agent_id)
+
+    _TOOL_MAP: dict[str, Any] = {
+        "agentnet_discover": lambda p: handlers.discover(**p),
+        "agentnet_discover_agents": lambda p: handlers.discover_agents(**p),
+        "agentnet_get_agent": lambda p: handlers.get_agent(**p),
+        "agentnet_use_agent": lambda p: handlers.use_agent(**p),
+        "agentnet_continue_session": lambda p: handlers.continue_session(**p),
+        "agentnet_settle_session": lambda p: handlers.settle_session(**p),
+        "agentnet_wallet": lambda p: handlers.wallet(**p),
+        "agentnet_wallet_topup": lambda p: handlers.wallet_topup(**p),
+    }
+
+    while True:
+        try:
+            line = _read_line()
+        except EOFError:
+            break
+
+        # C-4: Handle malformed JSON
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            _write_response(_error_response(None, -32700, "Parse error"))
+            continue
+
+        try:
+            req_id = req.get("id")  # may be absent for notifications
+
+            # H-5: Validate JSON-RPC envelope
+            if req.get("jsonrpc") != "2.0":
+                if req_id is not None:
+                    _write_response(_error_response(req_id, -32600, "Invalid Request"))
+                continue
+
+            method = req.get("method", "")
+            params = req.get("params", {})
+
+            # M-4: Notifications (no "id") must not receive responses
+            is_notification = "id" not in req
+
+            if method == "initialize":
+                if not is_notification:
+                    _write_response(_success_response(req_id, {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {"tools": {}},
+                        "serverInfo": {"name": "agentnet", "version": __version__},
+                    }))
+                continue
+
+            if method.startswith("notifications/"):
+                continue
+
+            if method == "tools/list":
+                if not is_notification:
+                    _write_response(_success_response(req_id, {"tools": TOOL_DEFINITIONS}))
+                continue
+
+            if method == "tools/call":
+                tool_name = params.get("name", "")
+                tool_args = params.get("arguments", {})
+                handler = _TOOL_MAP.get(tool_name)
+                if not handler:
+                    if not is_notification:
+                        _write_response(_error_response(req_id, -32601, f"Unknown tool: {tool_name}"))
+                    continue
+                try:
+                    result = handler(tool_args)
+                    if not is_notification:
+                        _write_response(_success_response(req_id, {
+                            "content": [{"type": "text", "text": json.dumps(result, indent=2)}],
+                        }))
+                except TypeError as exc:
+                    # M-2: Extra/unexpected arguments cause TypeError
+                    print(f"Tool error: {exc}", file=sys.stderr)
+                    if not is_notification:
+                        _write_response(_error_response(req_id, -32602, "Unexpected tool parameters"))
+                except Exception as exc:
+                    # C-3: Do not leak raw exception messages to clients
+                    print(f"Tool error: {exc}", file=sys.stderr)
+                    if not is_notification:
+                        _write_response(_error_response(req_id, -32000, "Tool execution failed"))
+                continue
+
+            # Unknown method
+            if not is_notification:
+                _write_response(_error_response(req_id, -32601, f"Unknown method: {method}"))
+
+        except Exception as exc:
+            # H-6: Catch-all so exceptions outside tools/call don't crash the server
+            print(f"Server error: {exc}", file=sys.stderr)
+            try:
+                err_id = req.get("id") if isinstance(req, dict) else None
+                _write_response(_error_response(err_id, -32603, "Internal error"))
+            except Exception:
+                pass

agentnet_cli/mcp/tools.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from ..platform.client import PlatformClient
+
+
+class ToolHandlers:
+    def __init__(
+        self,
+        *,
+        platform_url: str,
+        api_token: str,
+        agent_id: str,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self._client = PlatformClient(
+            base_url=platform_url,
+            api_token=api_token,
+            http_client=http_client or httpx.Client(timeout=30.0),
+        )
+        self._agent_id = agent_id
+
+    def discover(
+        self,
+        *,
+        query: str,
+        category: str | None = None,
+        max_results: int = 20,
+        max_price: int | None = None,
+    ) -> dict[str, Any]:
+        return self._client.discover(
+            query=query, category=category, max_results=max_results, max_price=max_price,
+        )
+
+    def discover_agents(self, *, query: str, limit: int = 20) -> dict[str, Any]:
+        return self._client.discover_agents(query=query, limit=limit)
+
+    def get_agent(self, *, agent_id: str) -> dict[str, Any]:
+        return self._client.get_agent(agent_id=agent_id)
+
+    def use_agent(
+        self, *, agent_id: str, task: str, max_amount: float = 0, quote_id: str | None = None,
+    ) -> dict[str, Any]:
+        if max_amount < 0 or max_amount > 1000:
+            raise ValueError("max_amount must be between 0 and 1000")
+        return self._client.use_agent(agent_id=agent_id, task=task, max_amount=max_amount, quote_id=quote_id)
+
+    def continue_session(self, *, session_id: str, message: str) -> dict[str, Any]:
+        return self._client.continue_session(session_id=session_id, message=message)
+
+    def settle_session(self, *, session_id: str) -> dict[str, Any]:
+        return self._client.settle_session(session_id=session_id)
+
+    def wallet(self, *, action: str, limit: int = 50) -> dict[str, Any]:
+        if action not in ("balance", "history"):
+            raise ValueError("Invalid action: must be 'balance' or 'history'")
+        if action == "balance":
+            return self._client.wallet_balance(agent_id=self._agent_id)
+        return self._client.wallet_history(agent_id=self._agent_id, limit=limit)
+
+    def wallet_topup(self, *, amount: float) -> dict[str, Any]:
+        if amount <= 0 or amount > 10000:
+            raise ValueError("amount must be between 0 (exclusive) and 10000")
+        return self._client.wallet_topup(agent_id=self._agent_id, amount=amount)

agentnet_cli/paths.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from enum import StrEnum
+from pathlib import Path
+
+
+class AgentName(StrEnum):
+    CLAUDE = "claude"
+    CURSOR = "cursor"
+    COPILOT = "copilot"
+    VSCODE = "vscode"
+    CODEX = "codex"
+    HERMES = "hermes"
+    OPENCLAW = "openclaw"
+
+
+_AGENT_DOT_DIRS: dict[AgentName, str] = {
+    AgentName.CLAUDE: ".claude",
+    AgentName.CURSOR: ".cursor",
+    AgentName.COPILOT: ".copilot",
+    AgentName.VSCODE: ".vscode",
+    AgentName.CODEX: ".codex",
+    AgentName.HERMES: ".hermes",
+    AgentName.OPENCLAW: ".openclaw",
+}
+
+_AGENT_BINARIES: dict[AgentName, list[str]] = {
+    AgentName.CLAUDE: ["claude"],
+    AgentName.CURSOR: ["cursor"],
+    AgentName.COPILOT: ["copilot"],
+    AgentName.VSCODE: ["code"],
+    AgentName.CODEX: ["codex"],
+    AgentName.HERMES: ["hermes"],
+    AgentName.OPENCLAW: ["openclaw"],
+}
+
+
+def agentnet_home() -> Path:
+    return Path.home() / ".agentnet"
+
+
+def agent_config_root(agent: AgentName) -> Path:
+    if agent == AgentName.CLAUDE and sys.platform == "win32":
+        appdata = os.environ.get("APPDATA", "")
+        if appdata:
+            return Path(appdata) / "Claude"
+    return Path.home() / _AGENT_DOT_DIRS[agent]
+
+
+def agent_binary_name(agent: AgentName) -> str:
+    return _AGENT_BINARIES[agent][0]
+
+
+_DISPLAY_NAMES: dict[AgentName, str] = {
+    AgentName.CLAUDE: "Claude",
+    AgentName.CURSOR: "Cursor",
+    AgentName.COPILOT: "GitHub Copilot",
+    AgentName.VSCODE: "VS Code",
+    AgentName.CODEX: "Codex",
+    AgentName.HERMES: "Hermes",
+    AgentName.OPENCLAW: "OpenClaw",
+}
+
+
+def agent_display_name(agent: AgentName) -> str:
+    return _DISPLAY_NAMES[agent]
+
+
+def short_path(p: Path | str | None) -> str:
+    if p is None:
+        return "—"
+    s = str(p)
+    home = str(Path.home())
+    if s.startswith(home):
+        return "~" + s[len(home):]
+    return s
+
+
+def find_agent_binary(agent: AgentName, custom_paths: dict[str, str] | None = None) -> Path | None:
+    if custom_paths and agent.value in custom_paths:
+        custom = Path(custom_paths[agent.value])
+        if custom.is_file():
+            return custom
+    for bin_name in _AGENT_BINARIES[agent]:
+        found = shutil.which(bin_name)
+        if found:
+            return Path(found)
+    return None

agentnet_cli/platform/README.md

@@ -0,0 +1,79 @@
+# Platform Client
+
+HTTP client for the Agent-net platform API at `app.agentnet.market`.
+
+## API Routes
+
+The platform is a FastAPI app behind nginx. All routes are accessible at `https://app.agentnet.market/<path>`.
+
+### Discovery
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/discover/` | Search agents (returns `DiscoveryResult[]`) |
+| `GET` | `/discover/listings` | Search listings with filters (category, price, tags) |
+
+Query params for `/discover/listings`:
+- `q` — search query
+- `category` — filter by category
+- `min_price`, `max_price` — price range
+- `tags` — comma-separated tag filter
+- `listing_type` — `service` or `product`
+- `limit`, `offset` — pagination
+
+### Agents
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/agents/` | List all agents |
+| `GET` | `/agents/{agent_id}` | Get agent details |
+| `POST` | `/agents/{agent_id}/use` | Start escrow session |
+| `POST` | `/agents/sessions/{id}/continue` | Continue session |
+| `POST` | `/agents/sessions/{id}/settle` | Settle transaction |
+| `POST` | `/agents/sessions/{id}/refund` | Refund transaction |
+
+### Wallet
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/wallet/{agent_id}` | Get balance (returns `balance_minor`, `currency`) |
+| `GET` | `/wallet/{agent_id}/history` | Transaction history |
+| `POST` | `/wallet/{agent_id}/topup` | Add funds |
+
+### Auth
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/auth/me` | Verify token, get current user |
+| `POST` | `/auth/login` | Login |
+| `POST` | `/auth/signup` | Register |
+
+## Authentication
+
+All authenticated endpoints use `Authorization: Bearer <api_key>` header. The API key is verified against the `api_keys` table via PBKDF2 hash comparison. Keys are issued per-org from the Agent-net dashboard.
+
+## Response Formats
+
+Wallet balance:
+```json
+{
+  "wallet_id": "...",
+  "agent_id": "...",
+  "balance_minor": 50000,
+  "currency": "INR",
+  "status": "active"
+}
+```
+
+Discovery results:
+```json
+[
+  {
+    "agent_id": "...",
+    "name": "TranslatorBot",
+    "description": "...",
+    "capabilities": [...],
+    "sponsored": false
+  }
+]
+```

agentnet_cli/platform/client.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import httpx
+
+
+class PlatformError(Exception):
+    pass
+
+
+def _validate_path_segment(value: str) -> None:
+    """Reject values that could cause path traversal or injection."""
+    if not re.fullmatch(r"[a-zA-Z0-9_-]+", value):
+        raise PlatformError(f"Invalid identifier: {value!r}")
+
+
+class PlatformClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_token: str,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self._base = base_url.rstrip("/")
+        self._token = api_token
+        self._http = http_client or httpx.Client(timeout=30.0)
+
+    # -- context manager & cleanup (L-4) --
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "PlatformClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    # -- internal helpers --
+
+    def _headers(self) -> dict[str, str]:
+        from .. import __version__  # noqa: PLC0415
+
+        return {
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/json",
+            "User-Agent": f"agentnet-cli/{__version__}",
+        }
+
+    def _handle_response(self, resp: httpx.Response) -> dict[str, Any]:
+        """Raise PlatformError on HTTP errors; safely parse JSON (H-11)."""
+        try:
+            resp.raise_for_status()
+        except httpx.HTTPStatusError:
+            status = resp.status_code
+            if status in (401, 403):
+                raise PlatformError("Authentication failed") from None
+            if status == 429:
+                raise PlatformError("Rate limited, try again later") from None
+            if 500 <= status < 600:
+                raise PlatformError("Platform server error") from None
+            raise PlatformError(f"Request failed ({status})") from None
+        try:
+            return resp.json()
+        except ValueError:
+            raise PlatformError("Invalid response from platform") from None
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        resp = self._http.get(f"{self._base}{path}", headers=self._headers(), params=params)
+        return self._handle_response(resp)
+
+    def _post(self, path: str, body: dict[str, Any]) -> dict[str, Any]:
+        resp = self._http.post(f"{self._base}{path}", headers=self._headers(), json=body)
+        return self._handle_response(resp)
+
+    def discover(self, *, query: str, category: str | None = None, max_results: int = 5, max_price: int | None = None) -> dict[str, Any]:
+        params: dict[str, Any] = {"q": query, "limit": max_results}
+        if category:
+            params["category"] = category
+        if max_price is not None:
+            params["max_price"] = max_price
+        return self._get("/discover/listings", params)
+
+    def discover_agents(self, *, query: str, limit: int = 20) -> dict[str, Any]:
+        return self._get("/discover/", {"q": query, "limit": limit})
+
+    def get_agent(self, *, agent_id: str) -> dict[str, Any]:
+        _validate_path_segment(agent_id)
+        return self._get(f"/agents/{agent_id}")
+
+    def list_agents(self) -> dict[str, Any]:
+        return self._get("/agents/")
+
+    def use_agent(self, *, agent_id: str, task: str, quote_id: str | None = None, max_amount: float = 0) -> dict[str, Any]:
+        _validate_path_segment(agent_id)
+        body: dict[str, Any] = {"message": task, "amount": max_amount}
+        return self._post(f"/agents/{agent_id}/use", body)
+
+    def continue_session(self, *, session_id: str, message: str) -> dict[str, Any]:
+        return self._post(f"/agents/sessions/{session_id}/continue", {"message": message})
+
+    def settle_session(self, *, session_id: str) -> dict[str, Any]:
+        return self._post(f"/agents/sessions/{session_id}/settle", {})
+
+    def wallet_balance(self, *, agent_id: str) -> dict[str, Any]:
+        _validate_path_segment(agent_id)
+        return self._get(f"/wallet/{agent_id}")
+
+    def wallet_history(self, *, agent_id: str, limit: int = 50) -> dict[str, Any]:
+        _validate_path_segment(agent_id)
+        return self._get(f"/wallet/{agent_id}/history", {"limit": limit})
+
+    def wallet_topup(self, *, agent_id: str, amount: float) -> dict[str, Any]:
+        _validate_path_segment(agent_id)
+        return self._post(f"/wallet/{agent_id}/topup", {"amount": amount})
+
+    def verify_token(self) -> dict[str, Any]:
+        return self._get("/auth/me")
+
+    def token_info(self) -> dict[str, Any]:
+        return self._get("/auth/token-info")
+
+    def cli_register_agent(
+        self, *, name: str, visibility: str = "private", description: str = "", url: str = "", tags: list[str] | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"name": name, "visibility": visibility, "description": description}
+        if url:
+            body["url"] = url
+        if tags:
+            body["tags"] = tags
+        return self._post("/auth/cli/register-agent", body)