agentnet-cli 0.1.0__py3-none-any.whl

agentnet_cli/agents/openclaw.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any
+from ..paths import AgentName, agent_config_root, agentnet_home
+from .base import AgentConnector, ConnectionResult, DetectionResult
+
+
+class OpenClawConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        root = agent_config_root(AgentName.OPENCLAW)
+        if not root.exists():
+            return DetectionResult(agent_name=AgentName.OPENCLAW, detected=False)
+        if (root / "openclaw.json").exists():
+            return DetectionResult(agent_name=AgentName.OPENCLAW, detected=True, config_root=root)
+        return DetectionResult(agent_name=AgentName.OPENCLAW, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        root = agent_config_root(AgentName.OPENCLAW)
+        config_path = root / "openclaw.json"
+        data: dict[str, Any] = {}
+        if config_path.exists():
+            data = json.loads(config_path.read_text())
+            backup = agentnet_home() / "backups" / "openclaw" / "openclaw.json.bak"
+            backup.parent.mkdir(parents=True, exist_ok=True)
+            backup.write_bytes(config_path.read_bytes())
+        plugins = data.setdefault("plugins", {})
+        plugins["agentnet-gateway"] = {
+            "enabled": True,
+            "config": {
+                "platformUrl": platform_config.get("platform_url", ""),
+                "platformToken": platform_config.get("api_token", ""),
+            },
+        }
+        config_path.write_text(json.dumps(data, indent=2) + "\n")
+        if os.name != "nt":
+            config_path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        return ConnectionResult(
+            success=True,
+            mcp_entry={"scope": "user", "file": str(config_path), "server_name": "agentnet-gateway"},
+        )
+
+    def disconnect(self, connection_manifest: dict[str, Any]) -> bool:
+        mcp_info = connection_manifest.get("mcp_registered", {})
+        mcp_file = mcp_info.get("file")
+        if mcp_file:
+            config_path = Path(mcp_file)
+            if config_path.exists():
+                data = json.loads(config_path.read_text())
+                data.get("plugins", {}).pop("agentnet-gateway", None)
+                config_path.write_text(json.dumps(data, indent=2) + "\n")
+        return True

agentnet_cli/agents/registry.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from ..paths import AgentName
+from .base import AgentConnector
+from .claude import ClaudeConnector
+from .cursor import CursorConnector
+from .copilot import CopilotConnector
+from .vscode import VSCodeConnector
+from .codex import CodexConnector
+from .hermes import HermesConnector
+from .openclaw import OpenClawConnector
+
+_CONNECTORS: dict[AgentName, type[AgentConnector]] = {
+    AgentName.CLAUDE: ClaudeConnector,
+    AgentName.CURSOR: CursorConnector,
+    AgentName.COPILOT: CopilotConnector,
+    AgentName.VSCODE: VSCodeConnector,
+    AgentName.CODEX: CodexConnector,
+    AgentName.HERMES: HermesConnector,
+    AgentName.OPENCLAW: OpenClawConnector,
+}
+
+
+def get_connector(agent: AgentName) -> AgentConnector:
+    return _CONNECTORS[agent]()
+
+
+def all_connectors() -> dict[AgentName, AgentConnector]:
+    return {name: cls() for name, cls in _CONNECTORS.items()}

agentnet_cli/agents/shims.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+_SHIMS_DIR = Path(__file__).resolve().parent.parent / "shims"
+
+
+def load_shim(relative_path: str) -> str:
+    context = (_SHIMS_DIR / "shared" / "context.md").read_text()
+    template = (_SHIMS_DIR / relative_path).read_text()
+    return template.replace("{{CONTEXT}}", context)

agentnet_cli/agents/vscode.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ..paths import AgentName, agent_config_root, agentnet_home
+from .base import AgentConnector, ConnectionResult, DetectionResult
+from .shims import load_shim
+
+
+def _vscode_user_dirs() -> list[Path]:
+    system = platform.system()
+    home = Path.home()
+    candidates: list[Path] = []
+
+    if system == "Darwin":
+        base = home / "Library" / "Application Support"
+        for variant in ["Code", "Code - Insiders"]:
+            candidates.append(base / variant / "User")
+    elif system == "Linux":
+        config = Path(os.environ.get("XDG_CONFIG_HOME", home / ".config"))
+        for variant in ["Code", "Code - Insiders"]:
+            candidates.append(config / variant / "User")
+    elif system == "Windows":
+        appdata = Path(os.environ.get("APPDATA", home / "AppData" / "Roaming"))
+        for variant in ["Code", "Code - Insiders"]:
+            candidates.append(appdata / variant / "User")
+
+    return [p for p in candidates if p.exists()]
+
+
+class VSCodeConnector(AgentConnector):
+    def detect(self) -> DetectionResult:
+        dot_vscode = agent_config_root(AgentName.VSCODE)
+        has_extensions = dot_vscode.exists() and (dot_vscode / "extensions").exists()
+        user_dirs = _vscode_user_dirs()
+        if has_extensions or user_dirs:
+            config_root = user_dirs[0] if user_dirs else dot_vscode
+            return DetectionResult(
+                agent_name=AgentName.VSCODE,
+                detected=True,
+                config_root=config_root,
+            )
+        return DetectionResult(agent_name=AgentName.VSCODE, detected=False)
+
+    def connect(self, platform_config: dict[str, Any]) -> ConnectionResult:
+        files_created: list[Path] = []
+        files_modified: list[tuple[Path, Path]] = []
+        mcp_entry_info: dict[str, Any] = {}
+        mcp_config = self._build_mcp_entry()
+
+        vscode_files: list[str] = []
+        for user_dir in _vscode_user_dirs():
+            mcp_path = user_dir / "mcp.json"
+            backup = agentnet_home() / "backups" / "vscode" / mcp_path.parent.parent.name / "mcp.json.bak"
+            backup.parent.mkdir(parents=True, exist_ok=True)
+            if mcp_path.exists():
+                backup.write_bytes(mcp_path.read_bytes())
+                files_modified.append((mcp_path, backup))
+            self._merge_mcp(mcp_path, mcp_config)
+            vscode_files.append(str(mcp_path))
+
+        mcp_entry_info["vscode_files"] = vscode_files
+
+        user_dirs = _vscode_user_dirs()
+        instructions_dir = user_dirs[0] if user_dirs else agent_config_root(AgentName.VSCODE)
+        instructions_path = instructions_dir / ".github" / "copilot-instructions.md"
+        instructions_path.parent.mkdir(parents=True, exist_ok=True)
+        instructions_path.write_text(load_shim("vscode/instructions.md"))
+        files_created.append(instructions_path)
+
+        return ConnectionResult(
+            success=True,
+            files_created=files_created,
+            files_modified=files_modified,
+            mcp_entry=mcp_entry_info,
+        )
+
+    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", {})
+        for vsc_path_str in mcp_info.get("vscode_files", []):
+            vsc_path = Path(vsc_path_str)
+            if vsc_path.exists():
+                data = json.loads(vsc_path.read_text())
+                data.get("servers", {}).pop("agentnet", None)
+                vsc_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]) -> None:
+        data: dict[str, Any] = {}
+        if mcp_path.exists():
+            data = json.loads(mcp_path.read_text())
+        data.setdefault("servers", {})
+        data["servers"]["agentnet"] = entry
+        mcp_path.parent.mkdir(parents=True, exist_ok=True)
+        mcp_path.write_text(json.dumps(data, indent=2) + "\n")

agentnet_cli/commands/agent.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import typer
+
+from ..marketplace import die, get_client, output
+from ..platform.client import PlatformError
+
+
+def agent(
+    agent_id: str = typer.Argument(help="Agent ID from discovery results"),
+) -> None:
+    """Get full details about an agent — skills, pricing, trust score."""
+    client = get_client()
+    try:
+        result = client.get_agent(agent_id=agent_id)
+        output(result)
+    except PlatformError as e:
+        die(str(e))
+
+
+def hire(
+    agent_id: str = typer.Argument(help="Agent to hire"),
+    task: str = typer.Option(..., "--task", "-t", help="Task description"),
+    budget: float = typer.Option(0, "--budget", "-b", help="Max budget in USD"),
+) -> None:
+    """Hire an agent to do a task. Returns result or session_id for follow-up."""
+    client = get_client()
+    try:
+        result = client.use_agent(agent_id=agent_id, task=task, max_amount=budget)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

agentnet_cli/commands/discover.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typer
+
+from ..marketplace import die, get_client, output
+from ..platform.client import PlatformError
+
+
+def discover(
+    query: str = typer.Argument(help="What to search for"),
+    category: str | None = typer.Option(None, help="Filter by category"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Max results"),
+    max_price: int | None = typer.Option(None, "--max-price", help="Max price in USD"),
+) -> None:
+    """Search the Agent-net marketplace for products and services."""
+    client = get_client()
+    try:
+        result = client.discover(query=query, category=category, max_results=limit, max_price=max_price)
+        output(result)
+    except PlatformError as e:
+        die(str(e))
+
+
+def agents(
+    query: str = typer.Argument(help="Agent name or capability to search for"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Max results"),
+) -> None:
+    """Search for AI agents by name or capability."""
+    client = get_client()
+    try:
+        result = client.discover_agents(query=query, limit=limit)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

agentnet_cli/commands/session.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import typer
+
+from ..marketplace import die, get_client, output
+from ..platform.client import PlatformError
+
+session_app = typer.Typer(help="Manage multi-turn agent sessions.")
+
+
+@session_app.command(name="continue")
+def continue_session(
+    session_id: str = typer.Argument(help="Session ID from a previous hire"),
+    message: str = typer.Option(..., "--message", "-m", help="Follow-up message"),
+) -> None:
+    """Send a follow-up message in a multi-turn session."""
+    client = get_client()
+    try:
+        result = client.continue_session(session_id=session_id, message=message)
+        output(result)
+    except PlatformError as e:
+        die(str(e))
+
+
+@session_app.command()
+def settle(
+    session_id: str = typer.Argument(help="Session ID to settle"),
+) -> None:
+    """Confirm satisfaction and release payment for a session."""
+    client = get_client()
+    try:
+        result = client.settle_session(session_id=session_id)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

agentnet_cli/commands/wallet.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import typer
+
+from ..marketplace import die, get_agent_id, get_client, output
+from ..platform.client import PlatformError
+
+wallet_app = typer.Typer(help="Manage your Agent-net wallet.")
+
+
+@wallet_app.command()
+def balance() -> None:
+    """Check your current wallet balance."""
+    client = get_client()
+    aid = get_agent_id()
+    try:
+        result = client.wallet_balance(agent_id=aid)
+        output(result)
+    except PlatformError as e:
+        die(str(e))
+
+
+@wallet_app.command()
+def history(
+    limit: int = typer.Option(50, "--limit", "-l", help="Number of transactions to show"),
+) -> None:
+    """View recent wallet transactions."""
+    client = get_client()
+    aid = get_agent_id()
+    try:
+        result = client.wallet_history(agent_id=aid, limit=limit)
+        output(result)
+    except PlatformError as e:
+        die(str(e))
+
+
+@wallet_app.command()
+def topup(
+    amount: float = typer.Argument(help="Amount to add in USD"),
+) -> None:
+    """Add funds to your wallet."""
+    client = get_client()
+    aid = get_agent_id()
+    try:
+        result = client.wallet_topup(agent_id=aid, amount=amount)
+        output(result)
+    except PlatformError as e:
+        die(str(e))

agentnet_cli/config.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+import os
+import stat
+import sys
+from pathlib import Path
+from typing import Any
+
+from .paths import agentnet_home
+
+
+def _atomic_write(path: Path, content: str, *, restricted: bool = False) -> None:
+    """Write content atomically via temp file + rename."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    try:
+        tmp.write_text(content)
+        if restricted and os.name != "nt":
+            tmp.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        tmp.replace(path)
+    except BaseException:
+        tmp.unlink(missing_ok=True)
+        raise
+
+
+def _config_path() -> Path:
+    return agentnet_home() / "config.json"
+
+
+def load_config() -> dict[str, Any] | None:
+    path = _config_path()
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except json.JSONDecodeError:
+        print(f"Warning: {path} is corrupted, ignoring", file=sys.stderr)
+        return None
+
+
+def save_config(data: dict[str, Any]) -> None:
+    path = _config_path()
+    _atomic_write(path, json.dumps(data, indent=2) + "\n", restricted=True)
+
+
+def load_agent_paths() -> dict[str, str]:
+    config = load_config()
+    if not config:
+        return {}
+    return config.get("agent_paths", {})
+
+
+def save_agent_path(agent_name: str, binary_path: str) -> None:
+    config = load_config() or {}
+    paths = config.setdefault("agent_paths", {})
+    paths[agent_name] = binary_path
+    save_config(config)
+
+
+def remove_agent_path(agent_name: str) -> bool:
+    config = load_config() or {}
+    paths = config.get("agent_paths", {})
+    if agent_name not in paths:
+        return False
+    del paths[agent_name]
+    save_config(config)
+    return True

agentnet_cli/connect.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from rich.console import Console
+
+from .agents.registry import get_connector
+from .config import load_config
+from .detect import detect_all
+from .manifest import record_connection
+from .paths import AgentName, agent_display_name
+
+console = Console()
+
+
+def connect_command(agent_name: str | None = None, connect_all: bool = False) -> None:
+    config = load_config()
+    if not config or not config.get("api_token"):
+        console.print()
+        console.print("  [red]Not registered.[/red] Run [bold]agentnet register[/bold] first.")
+        console.print()
+        raise SystemExit(1)
+
+    if connect_all:
+        targets = [r.agent_name for r in detect_all() if r.detected and not r.already_connected]
+        if not targets:
+            console.print("\n  [dim]All detected agents are already connected.[/dim]\n")
+            return
+    elif agent_name:
+        try:
+            AgentName(agent_name)
+            targets = [agent_name]
+        except ValueError:
+            console.print(f"\n  [red]Error:[/red] Unknown agent [bold]{agent_name}[/bold]")
+            console.print(
+                "  [dim]Available: claude, cursor, copilot, vscode, codex, hermes, openclaw[/dim]\n"
+            )
+            raise SystemExit(1)
+    else:
+        console.print("\n  [red]Error:[/red] Specify an agent name or use [bold]--all[/bold]")
+        console.print("  [dim]Example: agentnet connect claude[/dim]\n")
+        raise SystemExit(1)
+
+    console.print()
+    succeeded = 0
+    for name in targets:
+        display = agent_display_name(AgentName(name))
+        connector = get_connector(AgentName(name))
+        detection = connector.detect()
+        if not detection.detected:
+            console.print(f"  [yellow]![/yellow] {display} not detected on this system, skipping")
+            continue
+
+        console.print(f"  Connecting {display}...")
+        result = connector.connect(config)
+        if result.success:
+            record_connection(
+                name,
+                files_created=result.files_created,
+                files_modified=result.files_modified,
+                mcp_entry=result.mcp_entry,
+            )
+            file_count = len(result.files_created)
+            mcp_info = " + MCP server registered" if result.mcp_entry else ""
+            console.print(
+                f"  [green]✓[/green] {display} connected ({file_count} file{'s' if file_count != 1 else ''} created{mcp_info})"
+            )
+            succeeded += 1
+        else:
+            console.print(f"  [red]✗[/red] {display} failed: {', '.join(result.errors)}")
+
+    if succeeded:
+        console.print(f"\n  [green]{succeeded} agent{'s' if succeeded != 1 else ''} connected.[/green]")
+        console.print("  [dim]Your agents can now discover and transact on Agent-net.[/dim]")
+    console.print()

agentnet_cli/detect.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from .agents.base import DetectionResult
+from .agents.registry import all_connectors
+from .config import load_agent_paths
+from .manifest import load_manifest
+from .paths import AgentName, find_agent_binary
+
+
+def detect_all() -> list[DetectionResult]:
+    manifest = load_manifest()
+    connected = set(manifest.get("connections", {}).keys())
+    custom_paths = load_agent_paths()
+    results: list[DetectionResult] = []
+    for name, connector in all_connectors().items():
+        result = connector.detect()
+        result.already_connected = name in connected
+        binary = find_agent_binary(AgentName(name), custom_paths)
+        if binary:
+            result.binary_path = binary
+            result.binary_found = True
+        results.append(result)
+    return results

agentnet_cli/disconnect.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from rich.console import Console
+
+from .agents.registry import get_connector
+from .manifest import load_manifest, remove_connection
+from .paths import AgentName, agent_display_name
+
+console = Console()
+
+
+def disconnect_command(agent_name: str | None = None, disconnect_all: bool = False) -> None:
+    manifest = load_manifest()
+    connections = manifest.get("connections", {})
+
+    if disconnect_all:
+        targets = list(connections.keys())
+        if not targets:
+            console.print("\n  [dim]No agents are currently connected.[/dim]\n")
+            return
+    elif agent_name:
+        if agent_name not in connections:
+            try:
+                display = agent_display_name(AgentName(agent_name))
+            except ValueError:
+                display = agent_name
+            console.print(f"\n  [yellow]![/yellow] {display} is not connected.\n")
+            return
+        targets = [agent_name]
+    else:
+        console.print("\n  [red]Error:[/red] Specify an agent name or use [bold]--all[/bold]")
+        console.print("  [dim]Example: agentnet disconnect claude[/dim]\n")
+        raise SystemExit(1)
+
+    console.print()
+    succeeded = 0
+    for name in targets:
+        try:
+            agent = AgentName(name)
+            display = agent_display_name(agent)
+        except ValueError:
+            console.print(f"  [yellow]![/yellow] Unknown agent {name}, skipping")
+            continue
+
+        connector = get_connector(agent)
+        entry = connections[name]
+        console.print(f"  Disconnecting {display}...")
+        ok = connector.disconnect(entry)
+        if ok:
+            remove_connection(name)
+            console.print(f"  [green]✓[/green] {display} disconnected")
+            succeeded += 1
+        else:
+            console.print(f"  [red]✗[/red] {display} — failed to disconnect cleanly")
+
+    if succeeded:
+        console.print(
+            f"\n  [green]{succeeded} agent{'s' if succeeded != 1 else ''} disconnected.[/green]"
+        )
+    console.print()

agentnet_cli/hermes_plugin/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from . import handlers, schemas
+
+_PLUGIN_DIR = Path(__file__).resolve().parent
+
+_HANDLER_MAP = {
+    "agentnet_discover": handlers.agentnet_discover,
+    "agentnet_discover_agents": handlers.agentnet_discover_agents,
+    "agentnet_get_agent": handlers.agentnet_get_agent,
+    "agentnet_use_agent": handlers.agentnet_use_agent,
+    "agentnet_continue_session": handlers.agentnet_continue_session,
+    "agentnet_settle_session": handlers.agentnet_settle_session,
+    "agentnet_wallet": handlers.agentnet_wallet,
+    "agentnet_wallet_topup": handlers.agentnet_wallet_topup,
+}
+
+
+def register(ctx):
+    for schema in schemas.SCHEMAS:
+        name = schema["name"]
+        ctx.register_tool(
+            name=name,
+            toolset="agentnet",
+            schema=schema,
+            handler=_HANDLER_MAP[name],
+        )
+
+    skills_dir = _PLUGIN_DIR / "skills"
+    if skills_dir.is_dir():
+        for child in sorted(skills_dir.iterdir()):
+            skill_md = child / "SKILL.md"
+            if child.is_dir() and skill_md.exists():
+                ctx.register_skill(child.name, skill_md)