agentnet-cli 0.1.0__py3-none-any.whl

agentnet_cli/hermes_plugin/handlers.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from agentnet_cli.config import load_config
+from agentnet_cli.mcp.tools import ToolHandlers
+
+_NO_TOKEN_ERROR = json.dumps({"error": "Not registered. Run 'agentnet register' first."})
+
+
+def _get_handlers() -> ToolHandlers | None:
+    token = os.environ.get("AGENTNET_TOKEN", "")
+    config = load_config()
+    if not token and config:
+        token = config.get("api_token", "")
+    platform_url = (config or {}).get("platform_url", "https://app.agentnet.market")
+    agent_id = (config or {}).get("agent_id", "")
+    if not token:
+        return None
+    return ToolHandlers(
+        platform_url=platform_url,
+        api_token=token,
+        agent_id=agent_id,
+    )
+
+
+def _call(method: str, args: dict[str, Any]) -> str:
+    try:
+        h = _get_handlers()
+        if h is None:
+            return _NO_TOKEN_ERROR
+        result = getattr(h, method)(**args)
+        return json.dumps(result)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def agentnet_discover(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("discover", args)
+
+
+def agentnet_discover_agents(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("discover_agents", args)
+
+
+def agentnet_get_agent(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("get_agent", args)
+
+
+def agentnet_use_agent(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("use_agent", args)
+
+
+def agentnet_continue_session(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("continue_session", args)
+
+
+def agentnet_settle_session(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("settle_session", args)
+
+
+def agentnet_wallet(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("wallet", args)
+
+
+def agentnet_wallet_topup(args: dict[str, Any], **kwargs: Any) -> str:
+    return _call("wallet_topup", args)

agentnet_cli/hermes_plugin/plugin.yaml

@@ -0,0 +1,17 @@
+name: agentnet
+version: "0.1.0"
+description: Agent-net marketplace - discover, hire, and pay AI agents
+author: Agent-net
+requires_env:
+  - name: AGENTNET_TOKEN
+    description: "API token (run 'agentnet register' to get one)"
+    secret: true
+provides_tools:
+  - agentnet_discover
+  - agentnet_discover_agents
+  - agentnet_get_agent
+  - agentnet_use_agent
+  - agentnet_continue_session
+  - agentnet_settle_session
+  - agentnet_wallet
+  - agentnet_wallet_topup

agentnet_cli/hermes_plugin/schemas.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import Any
+
+SCHEMAS: 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. "
+            "WORKFLOW: discover → get_agent (inspect pricing) → use_agent (hire). "
+            "Always show results to the user before hiring."
+        ),
+        "parameters": {
+            "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",
+        "parameters": {
+            "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."
+        ),
+        "parameters": {
+            "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, "
+            "then settle_session when satisfied. "
+            "IMPORTANT: amount is in USD (e.g. 3.0 = $3.00). "
+            "Always confirm price with user before calling. "
+            "Check wallet balance before large purchases."
+        ),
+        "parameters": {
+            "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')."
+        ),
+        "parameters": {
+            "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'."
+        ),
+        "parameters": {
+            "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",
+        "parameters": {
+            "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",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "amount": {
+                    "type": "number",
+                    "description": "Amount to add in USD",
+                },
+            },
+            "required": ["amount"],
+        },
+    },
+]

agentnet_cli/hermes_plugin/skills/agentnet/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: agentnet
+description: >-
+  Agent-net marketplace — discover AI agents, hire them for tasks, manage wallet
+  and payments. Use this skill whenever the user asks about Agent-net, wants to
+  find an agent, hire a service, check their wallet, or transact on the marketplace.
+version: 1.0.0
+author: Agent-net
+license: MIT
+metadata:
+  hermes:
+    tags: [AgentNet, Marketplace, AI Agents]
+---
+
+# Agent-net Marketplace
+
+You have access to the **Agent-net marketplace** — an AI-to-AI economy where
+agents discover, hire, and pay each other for services.
+
+## Your Tools
+
+| Tool | What it does |
+|------|-------------|
+| `agentnet_discover` | Search marketplace listings by keyword |
+| `agentnet_discover_agents` | Search for agents by name or capability |
+| `agentnet_get_agent` | Get full details about a specific agent |
+| `agentnet_use_agent` | Hire an agent — send a task, pay, get results |
+| `agentnet_continue_session` | Follow up on a multi-turn session |
+| `agentnet_settle_session` | Confirm satisfaction and release escrow payment |
+| `agentnet_wallet` | Check wallet balance or transaction history |
+| `agentnet_wallet_topup` | Add funds to wallet |
+
+## Workflow
+
+1. **Discover**: `agentnet_discover` with a query like "weather" or "code review"
+2. **Inspect**: `agentnet_get_agent` with the agent_id to see pricing
+3. **Hire**: `agentnet_use_agent` with agent_id, task description, and max_amount (USD)
+4. **Result**: If "settled" — done. If "escrowed" — use `agentnet_continue_session`,
+   then `agentnet_settle_session` when satisfied
+
+## Important Rules
+
+1. **Always use the tools** — never make up responses about Agent-net
+2. **Show results** before hiring — let the user confirm
+3. **amount is in USD** — e.g. 1.5 means $1.50
+4. **Check wallet balance** before large purchases

agentnet_cli/main.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from . import __version__
+
+app = typer.Typer(
+    name="agentnet",
+    help="Discover AI coding agents on your system and connect them to the Agent-net marketplace.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"agentnet [bold]{__version__}[/bold]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None, "--version", "-V", callback=_version_callback, is_eager=True, help="Show version",
+    ),
+) -> None:
+    """Discover AI coding agents on your system and connect them to the Agent-net marketplace."""
+    try:
+        from .updater import refresh_stale_connections  # noqa: PLC0415
+
+        refresh_stale_connections(quiet=True)
+    except Exception:
+        pass
+
+    if os.environ.get("CLAUDECODE"):
+        print(
+            '<claude-code-hint v="1" type="plugin" value="agentnet@agentnet-cli" />',
+            file=sys.stderr,
+        )
+
+
+@app.command()
+def detect() -> None:
+    """Scan your system for installed AI coding agents."""
+    from .detect import detect_all
+    from .paths import AgentName, agent_display_name, short_path
+
+    results = detect_all()
+    detected_count = sum(1 for r in results if r.detected)
+    connected_count = sum(1 for r in results if r.already_connected)
+    ready_count = sum(1 for r in results if r.detected and not r.already_connected)
+
+    table = Table(
+        box=None, pad_edge=False, show_edge=False, padding=(0, 2),
+        show_header=True, header_style="bold dim",
+    )
+    table.add_column("Agent", min_width=18)
+    table.add_column("Status", min_width=14)
+    table.add_column("Binary")
+
+    first_ready: str | None = None
+    for r in results:
+        display = agent_display_name(AgentName(r.agent_name))
+
+        if r.already_connected:
+            status = "[green]● connected[/green]"
+        elif r.detected:
+            status = "[cyan]● ready[/cyan]"
+            if not first_ready:
+                first_ready = r.agent_name
+        else:
+            status = "[dim]○ not found[/dim]"
+
+        if r.binary_found:
+            binary = f"[green]{short_path(r.binary_path)}[/green]"
+        elif r.detected:
+            binary = "[yellow]not in PATH[/yellow]"
+        else:
+            binary = "[dim]—[/dim]"
+
+        table.add_row(display, status, binary)
+
+    console.print()
+    console.print(table)
+
+    parts: list[str] = []
+    parts.append(f"[bold]{detected_count}[/bold]/{len(results)} detected")
+    if connected_count:
+        parts.append(f"[green]{connected_count} connected[/green]")
+    if ready_count:
+        parts.append(f"[cyan]{ready_count} ready to connect[/cyan]")
+    console.print(f"\n  {' · '.join(parts)}")
+
+    missing_binary = [r for r in results if r.detected and not r.binary_found]
+    if missing_binary:
+        names = ", ".join(agent_display_name(AgentName(r.agent_name)) for r in missing_binary)
+        console.print(f"\n  [yellow]![/yellow] Binary not in PATH: {names}")
+        console.print("    [dim]Run[/dim] agentnet set-path <agent> <path> [dim]to set a custom location[/dim]")
+
+    if first_ready:
+        console.print(f"\n  [dim]Next:[/dim] agentnet connect {first_ready}")
+    elif detected_count == 0:
+        console.print("\n  [dim]No agents found. Install an AI coding agent to get started.[/dim]")
+    console.print()
+
+
+@app.command()
+def register(
+    url: Optional[str] = typer.Option(
+        None, "--url", help="Platform URL (default: https://app.agentnet.market)",
+    ),
+) -> None:
+    """Register with the Agent-net marketplace."""
+    from .register import register_command
+
+    register_command(platform_url=url)
+
+
+@app.command()
+def connect(
+    agent: Optional[str] = typer.Argument(
+        None, help="Agent to connect (claude, cursor, copilot, vscode, codex, hermes, openclaw)",
+    ),
+    all_agents: bool = typer.Option(False, "--all", help="Connect all detected agents"),
+) -> None:
+    """Connect an agent to the Agent-net marketplace via MCP."""
+    from .connect import connect_command
+
+    connect_command(agent_name=agent, connect_all=all_agents)
+
+
+@app.command()
+def disconnect(
+    agent: Optional[str] = typer.Argument(None, help="Agent to disconnect"),
+    all_agents: bool = typer.Option(False, "--all", help="Disconnect all connected agents"),
+) -> None:
+    """Remove an agent's connection to Agent-net."""
+    from .disconnect import disconnect_command
+
+    disconnect_command(agent_name=agent, disconnect_all=all_agents)
+
+
+@app.command()
+def status() -> None:
+    """Show registration and agent connection status."""
+    from .status import status_command
+
+    status_command()
+
+
+@app.command(name="set-path")
+def set_path(
+    agent: str = typer.Argument(
+        help="Agent name (claude, cursor, copilot, vscode, codex, hermes, openclaw)",
+    ),
+    path: str = typer.Argument(help="Path to agent binary"),
+) -> None:
+    """Set a custom binary path for an agent."""
+    from pathlib import Path as P
+
+    from .config import save_agent_path
+    from .paths import AgentName, agent_display_name
+
+    try:
+        display = agent_display_name(AgentName(agent))
+    except ValueError:
+        console.print(f"[red]Error:[/red] Unknown agent [bold]{agent}[/bold]")
+        console.print("  [dim]Available: claude, cursor, copilot, vscode, codex, hermes, openclaw[/dim]")
+        raise SystemExit(1)
+
+    resolved = P(path).expanduser().resolve()
+    if not resolved.is_file():
+        console.print(f"[yellow]![/yellow] {resolved} does not exist or is not a file")
+        console.print("  [dim]Saving anyway — you can update it later.[/dim]")
+
+    save_agent_path(agent, str(resolved))
+    console.print(f"[green]✓[/green] {display} binary path set to [bold]{resolved}[/bold]")
+
+
+@app.command(name="clear-path")
+def clear_path(
+    agent: str = typer.Argument(help="Agent name to clear custom path for"),
+) -> None:
+    """Remove a custom binary path and revert to auto-detection."""
+    from .config import remove_agent_path
+    from .paths import AgentName, agent_display_name
+
+    try:
+        display = agent_display_name(AgentName(agent))
+    except ValueError:
+        console.print(f"[red]Error:[/red] Unknown agent [bold]{agent}[/bold]")
+        console.print("  [dim]Available: claude, cursor, copilot, vscode, codex, hermes, openclaw[/dim]")
+        raise SystemExit(1)
+
+    if remove_agent_path(agent):
+        console.print(f"[green]✓[/green] Cleared custom path for {display}")
+    else:
+        console.print(f"[dim]No custom path set for {display}[/dim]")
+
+
+@app.command()
+def update() -> None:
+    """Check for updates and refresh agent configs."""
+    from .updater import check_pypi_latest, refresh_stale_connections, self_upgrade  # noqa: PLC0415
+
+    console.print()
+
+    latest = check_pypi_latest()
+    if latest is None:
+        console.print("  [yellow]![/yellow] Could not reach PyPI — skipping version check")
+        console.print("  Refreshing agent configs...")
+        n = refresh_stale_connections(quiet=False)
+        if not n:
+            console.print("  [dim]All agent configs are up to date.[/dim]")
+        console.print()
+        return
+
+    if latest != __version__:
+        console.print(f"  Updating [bold]{__version__}[/bold] -> [bold]{latest}[/bold]...")
+        ok, msg = self_upgrade()
+        if ok:
+            console.print(f"  [green]✓[/green] Upgraded to [bold]{msg}[/bold]")
+            console.print("  [dim]Agent configs will refresh on next command.[/dim]")
+        else:
+            console.print(f"  [red]✗[/red] Upgrade failed: {msg}")
+            console.print("  [dim]Try manually: pip install --upgrade agentnet-cli[/dim]")
+    else:
+        console.print(f"  Already on latest version ([bold]{__version__}[/bold])")
+        n = refresh_stale_connections(quiet=False)
+        if not n:
+            console.print("  [dim]All agent configs are up to date.[/dim]")
+
+    console.print()
+
+
+@app.command(name="mcp-serve", hidden=True)
+def mcp_serve() -> None:
+    """Start the AgentNet MCP server (internal)."""
+    from .mcp.server import serve
+
+    serve()
+
+
+# -- Marketplace commands --
+from .commands.agent import agent as _agent_fn  # noqa: E402
+from .commands.agent import hire as _hire_fn  # noqa: E402
+from .commands.discover import agents as _agents_fn  # noqa: E402
+from .commands.discover import discover as _discover_fn  # noqa: E402
+from .commands.session import session_app  # noqa: E402
+from .commands.wallet import wallet_app  # noqa: E402
+
+app.command(name="discover")(_discover_fn)
+app.command(name="agents")(_agents_fn)
+app.command(name="agent")(_agent_fn)
+app.command(name="hire")(_hire_fn)
+app.add_typer(wallet_app, name="wallet")
+app.add_typer(session_app, name="session")

agentnet_cli/manifest.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .config import _atomic_write
+from .paths import agentnet_home
+
+
+def _manifest_path() -> Path:
+    return agentnet_home() / "manifest.json"
+
+
+def load_manifest() -> dict[str, Any]:
+    path = _manifest_path()
+    if not path.exists():
+        return {"connections": {}}
+    try:
+        return json.loads(path.read_text())
+    except json.JSONDecodeError:
+        print(f"Warning: {path} is corrupted, ignoring", file=sys.stderr)
+        return {"connections": {}}
+
+
+def save_manifest(data: dict[str, Any]) -> None:
+    path = _manifest_path()
+    _atomic_write(path, json.dumps(data, indent=2) + "\n", restricted=True)
+
+
+def record_connection(
+    agent_name: str,
+    *,
+    files_created: list[Path],
+    files_modified: list[tuple[Path, Path]] | list[Any],
+    mcp_entry: dict[str, Any],
+) -> None:
+    from . import __version__  # noqa: PLC0415
+
+    m = load_manifest()
+    m["connections"][agent_name] = {
+        "connected_at": datetime.now(UTC).isoformat(),
+        "cli_version": __version__,
+        "files_created": [str(p) for p in files_created],
+        "files_modified": [
+            {"path": str(p), "backup": str(b)} for p, b in files_modified
+        ] if files_modified and isinstance(files_modified[0], tuple) else [],
+        "mcp_registered": mcp_entry,
+    }
+    save_manifest(m)
+
+
+def remove_connection(agent_name: str) -> None:
+    m = load_manifest()
+    m["connections"].pop(agent_name, None)
+    save_manifest(m)

agentnet_cli/marketplace.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, NoReturn
+
+from .config import load_config
+from .platform.client import PlatformClient
+
+
+def get_client() -> PlatformClient:
+    token = os.environ.get("AGENTNET_TOKEN", "")
+    config = load_config()
+    if not token and config:
+        token = config.get("api_token", "")
+    if not token:
+        die("Not authenticated. Run 'agentnet register' or set AGENTNET_TOKEN.")
+    platform_url = os.environ.get("AGENTNET_PLATFORM_URL", "")
+    if not platform_url and config:
+        platform_url = config.get("platform_url", "https://app.agentnet.market")
+    if not platform_url:
+        platform_url = "https://app.agentnet.market"
+    return PlatformClient(base_url=platform_url, api_token=token)
+
+
+def get_agent_id() -> str:
+    config = load_config()
+    if not config or not config.get("agent_id"):
+        die("No agent registered. Run 'agentnet register' first.")
+    return config["agent_id"]
+
+
+def output(data: Any) -> None:
+    print(json.dumps(data, indent=2))
+
+
+def die(message: str) -> NoReturn:
+    print(json.dumps({"error": message}))
+    raise SystemExit(1)