agentnet-cli 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

agentnet_cli/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI entry point and command modules."""

agentnet_cli/cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core CLI commands: setup, connect, detect, register, status."""

agentnet_cli/{connect.py → cli/core/connect.py}

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from rich.console import Console
 
-from .agents.registry import get_connector
-from .config import load_config
+from ...connectors.registry import get_connector
+from ...infra.config import load_config
 from .detect import detect_all
-from .manifest import record_connection
-from .paths import AgentName, agent_display_name
+from ...infra.manifest import record_connection
+from ...infra.paths import AgentName, agent_display_name
 
 console = Console()
 

agentnet_cli/{detect.py → cli/core/detect.py}

@@ -1,10 +1,10 @@
 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
+from ...connectors.base import DetectionResult
+from ...connectors.registry import all_connectors
+from ...infra.config import load_agent_paths
+from ...infra.manifest import load_manifest
+from ...infra.paths import AgentName, find_agent_binary
 
 
 def detect_all() -> list[DetectionResult]:

agentnet_cli/{disconnect.py → cli/core/disconnect.py}

@@ -2,9 +2,9 @@ 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
+from ...connectors.registry import get_connector
+from ...infra.manifest import load_manifest, remove_connection
+from ...infra.paths import AgentName, agent_display_name
 
 console = Console()
 

agentnet_cli/{register.py → cli/core/register.py}

@@ -10,8 +10,8 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from .config import load_config, save_config
-from .platform.client import PlatformClient
+from ...infra.config import load_config, save_config
+from ...marketplace.client import PlatformClient
 
 console = Console()
 

agentnet_cli/{setup.py → cli/core/setup_wizard.py}

@@ -10,16 +10,16 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from .config import load_config
+from ...infra.config import load_config
 from .connect import connect_command
 from .detect import detect_all
-from .paths import AgentName, agent_display_name
+from ...infra.paths import AgentName, agent_display_name
 from .register import default_agent_name, register_command
 
 console = Console()
 
 
-def setup_command(platform_url: str | None = None) -> None:
+def setup_command(platform_url: str | None = None, *, choose: bool = False) -> None:
     config = load_config()
     if not config or not config.get("api_token"):
         console.print()
@@ -43,21 +43,25 @@ def setup_command(platform_url: str | None = None) -> None:
         return
 
     console.print()
-    console.print(
-        f"  [bold]Step 3:[/bold] Choose agents to configure "
-        f"([green]all recommended[/green], {len(targets)} available)"
-    )
-    selected, connect_all = _select_targets(targets)
-    if not selected:
-        console.print("\n  [dim]No agents configured.[/dim]\n")
-        return
-
-    if connect_all:
-        connect_command(connect_all=True)
+    if choose:
+        console.print(
+            f"  [bold]Step 3:[/bold] Choose agents to configure ({len(targets)} available)"
+        )
+        selected, connect_all = _select_targets(targets)
+        if not selected:
+            console.print("\n  [dim]No agents configured.[/dim]\n")
+            return
+        if connect_all:
+            connect_command(connect_all=True)
+            return
+        for agent_name in selected:
+            connect_command(agent_name=agent_name)
         return
 
-    for agent_name in selected:
-        connect_command(agent_name=agent_name)
+    console.print(
+        f"  [bold]Step 3:[/bold] Configuring all detected agents ({len(targets)})"
+    )
+    connect_command(connect_all=True)
 
 
 def _available_targets(results) -> list[str]:

agentnet_cli/{status.py → cli/core/status.py}

@@ -3,9 +3,9 @@ from __future__ import annotations
 from rich.console import Console
 from rich.table import Table
 
-from .config import load_config
+from ...infra.config import load_config
 from .detect import detect_all
-from .paths import AgentName, agent_display_name, short_path
+from ...infra.paths import AgentName, agent_display_name, short_path
 
 console = Console()
 
@@ -23,9 +23,6 @@ def status_command() -> None:
     console.print(f"  URL:    {config.get('platform_url')}")
     token = config.get("api_token", "")
     console.print(f"  Token:  [dim]...{token[-6:]}[/dim]" if len(token) > 6 else "  Token:  [dim]configured[/dim]")
-    if config.get("wallet_id"):
-        console.print(f"  Wallet: {config['wallet_id']}")
-
     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)

agentnet_cli/cli/core/updater.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+from rich.console import Console
+
+from agentnet_cli import __version__
+from ...connectors.registry import get_connector
+from ...infra.config import load_config
+from ...infra.manifest import load_manifest, record_connection, record_update_check, should_check_for_update
+from ...infra.paths import AgentName
+
+_err = Console(stderr=True)
+
+_DEFAULT_CHECK_INTERVAL_HOURS = 24.0
+
+
+@dataclass
+class AutoUpdateResult:
+    checked: bool = False
+    upgrade_started: bool = False
+    upgraded: bool = False
+    refreshed: int = 0
+    message: str | None = None
+
+
+def _auto_update_enabled() -> bool:
+    return os.environ.get("AGENTNET_AUTO_UPDATE", "1").strip().lower() not in {"0", "false", "no"}
+
+
+def _check_interval_hours() -> float:
+    raw = os.environ.get("AGENTNET_UPDATE_CHECK_INTERVAL_HOURS", "").strip()
+    if not raw:
+        return _DEFAULT_CHECK_INTERVAL_HOURS
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return _DEFAULT_CHECK_INTERVAL_HOURS
+
+
+def refresh_stale_connections(*, quiet: bool = False) -> int:
+    """Re-run connect() for agents whose manifest cli_version != current version."""
+    config = load_config()
+    if not config or not config.get("api_token"):
+        return 0
+
+    manifest = load_manifest()
+    connections = manifest.get("connections", {})
+    if not connections:
+        return 0
+
+    refreshed = 0
+    for agent_name, conn_info in list(connections.items()):
+        if conn_info.get("cli_version") == __version__:
+            continue
+
+        try:
+            agent_enum = AgentName(agent_name)
+            connector = get_connector(agent_enum)
+            detection = connector.detect()
+            if not detection.detected:
+                continue
+
+            result = connector.connect(config)
+            if result.success:
+                record_connection(
+                    agent_name,
+                    files_created=result.files_created,
+                    files_modified=result.files_modified,
+                    mcp_entry=result.mcp_entry,
+                )
+                refreshed += 1
+            else:
+                print(f"Warning: refresh for {agent_name} returned success=False", file=sys.stderr)
+        except (OSError, ValueError, KeyError) as exc:
+            print(f"Warning: failed to refresh {agent_name}: {exc}", file=sys.stderr)
+            continue
+
+    if refreshed and not quiet:
+        _err.print(
+            f"  [dim]Refreshed {refreshed} agent config(s) for v{__version__}[/dim]"
+        )
+
+    return refreshed
+
+
+def check_pypi_latest() -> str | None:
+    """Check PyPI for the latest published version."""
+    try:
+        import httpx  # noqa: PLC0415
+
+        resp = httpx.get(
+            "https://pypi.org/pypi/agentnet-cli/json",
+            timeout=5.0,
+            follow_redirects=True,
+        )
+        if resp.status_code == 200:
+            return resp.json()["info"]["version"]
+    except Exception:
+        pass
+    return None
+
+
+def detect_install_method() -> str:
+    """Human-readable label for how this install will be upgraded."""
+    cmd = _upgrade_command()
+    if cmd[:2] == ["uv", "tool"]:
+        return "uv tool"
+    if cmd[0] == "pipx":
+        return "pipx"
+    if cmd[0] == "npm":
+        return "npm"
+    return "pip"
+
+
+def self_upgrade(*, background: bool = False, verbose: bool = False) -> tuple[bool, str]:
+    """Upgrade agentnet-cli to latest. Returns (success, message)."""
+    cmd = _upgrade_command()
+    try:
+        if background:
+            subprocess.Popen(  # noqa: S603
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            latest = check_pypi_latest()
+            return True, latest or "latest"
+
+        if verbose:
+            result = subprocess.run(cmd, timeout=300)  # noqa: S603
+            detail = ""
+        else:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)  # noqa: S603
+            detail = result.stderr.strip()[:200]
+
+        if result.returncode == 0:
+            latest = check_pypi_latest()
+            return True, latest or "latest"
+        return False, detail or f"exit code {result.returncode}"
+    except Exception as e:
+        return False, str(e)
+
+
+def _spawn_refresh_with_upgraded_binary(*, quiet: bool = False) -> int:
+    """Re-invoke the upgraded agentnet binary so integrations refresh at the new version."""
+    agentnet_bin = shutil.which("agentnet")
+    args = ["update", "--refresh-only"]
+    if quiet:
+        args.append("--quiet")
+    if agentnet_bin:
+        proc = subprocess.run([agentnet_bin, *args], timeout=120)  # noqa: S603
+        return proc.returncode
+    return 0
+
+
+def clean_update(*, quiet: bool = False, refresh_only: bool = False) -> AutoUpdateResult:
+    """User-facing update: upgrade the package, then refresh integrations from the new install."""
+    if refresh_only:
+        refreshed = refresh_stale_connections(quiet=quiet)
+        return AutoUpdateResult(checked=True, refreshed=refreshed)
+
+    result = AutoUpdateResult(checked=True)
+    latest = check_pypi_latest()
+    record_update_check()
+
+    if latest is None:
+        result.message = "Could not reach PyPI"
+        result.refreshed = refresh_stale_connections(quiet=quiet)
+        return result
+
+    if latest == __version__:
+        result.message = f"Already on latest version ({__version__})"
+        result.refreshed = refresh_stale_connections(quiet=quiet)
+        return result
+
+    method = detect_install_method()
+    if not quiet:
+        _err.print(
+            f"  Upgrading [bold]{__version__}[/bold] → [bold]{latest}[/bold] via {method}..."
+        )
+
+    ok, msg = self_upgrade(background=False, verbose=not quiet)
+    if not ok:
+        result.message = f"Upgrade failed: {msg}"
+        return result
+
+    result.upgraded = True
+    result.message = f"Upgraded to {msg}"
+    record_update_check(upgraded_to=msg)
+
+    if not quiet:
+        _err.print("  [dim]Refreshing agent integrations...[/dim]")
+
+    _spawn_refresh_with_upgraded_binary(quiet=quiet)
+    return result
+
+
+def run_update(*, quiet: bool = False, background: bool = False, force: bool = False) -> AutoUpdateResult:
+    """Check PyPI, upgrade if needed, then refresh stale agent integrations."""
+    result = AutoUpdateResult()
+    interval = _check_interval_hours()
+
+    if not force and not should_check_for_update(interval):
+        result.refreshed = refresh_stale_connections(quiet=quiet)
+        return result
+
+    result.checked = True
+    latest = check_pypi_latest()
+    record_update_check()
+
+    if latest is None:
+        result.message = "Could not reach PyPI"
+        result.refreshed = refresh_stale_connections(quiet=quiet)
+        if not quiet:
+            _err.print("  [yellow]![/yellow] Could not reach PyPI — skipping version check")
+        return result
+
+    if _auto_update_enabled() and latest != __version__:
+        ok, msg = self_upgrade(background=background)
+        if ok:
+            if background:
+                result.upgrade_started = True
+                result.message = f"Upgrade to {msg} started in background"
+            else:
+                result.upgraded = True
+                result.message = f"Upgraded to {msg}"
+                record_update_check(upgraded_to=msg)
+        else:
+            result.message = f"Upgrade failed: {msg}"
+            if not quiet:
+                _err.print(f"  [red]✗[/red] Upgrade failed: {msg}")
+    elif not quiet and latest == __version__:
+        result.message = f"Already on latest version ({__version__})"
+
+    result.refreshed = refresh_stale_connections(quiet=quiet)
+    return result
+
+
+def maybe_auto_update(*, quiet: bool = True) -> AutoUpdateResult:
+    """Rate-limited silent auto-update used by CLI callback and MCP startup."""
+    if not _auto_update_enabled():
+        refreshed = refresh_stale_connections(quiet=quiet)
+        return AutoUpdateResult(refreshed=refreshed)
+    return run_update(quiet=quiet, background=True)
+
+
+def _upgrade_command() -> list[str]:
+    """Detect install method and return the right upgrade command."""
+    if shutil.which("uv"):
+        try:
+            r = subprocess.run(
+                ["uv", "tool", "list"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if re.search(r"^agentnet-cli\b", r.stdout, re.MULTILINE):
+                return ["uv", "tool", "upgrade", "agentnet-cli"]
+        except Exception:
+            pass
+
+    if shutil.which("pipx"):
+        try:
+            r = subprocess.run(
+                ["pipx", "list", "--short"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if re.search(r"^agentnet-cli\b", r.stdout, re.MULTILINE):
+                return ["pipx", "upgrade", "agentnet-cli"]
+        except Exception:
+            pass
+
+    if shutil.which("npm"):
+        try:
+            r = subprocess.run(
+                ["npm", "list", "-g", "--depth=0", "agentnet-cli"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if re.search(r"^agentnet-cli@", r.stdout, re.MULTILINE):
+                return ["npm", "install", "-g", "agentnet-cli@latest"]
+        except Exception:
+            pass
+
+    return [sys.executable, "-m", "pip", "install", "--upgrade", "agentnet-cli"]

agentnet_cli/{main.py → cli/main.py}

@@ -8,7 +8,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from . import __version__
+from agentnet_cli import __version__
 
 app = typer.Typer(
     name="agentnet",
@@ -32,9 +32,9 @@ def main(
 ) -> 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
+        from .core.updater import maybe_auto_update  # noqa: PLC0415
 
-        refresh_stale_connections(quiet=True)
+        maybe_auto_update(quiet=True)
     except Exception:
         pass
 
@@ -48,8 +48,8 @@ def main(
 @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
+    from .core.detect import detect_all
+    from ..infra.paths import AgentName, agent_display_name, short_path
 
     results = detect_all()
     detected_count = sum(1 for r in results if r.detected)
@@ -117,7 +117,7 @@ def register(
     ),
 ) -> None:
     """Sign in through the browser and register a CLI identity."""
-    from .register import register_command
+    from .core.register import register_command
 
     register_command(platform_url=url)
 
@@ -127,11 +127,16 @@ def setup(
     url: Optional[str] = typer.Option(
         None, "--url", help="Platform URL (default: https://app.agentnet.market)",
     ),
+    choose: bool = typer.Option(
+        False,
+        "--choose",
+        help="Interactively choose which detected agents to configure",
+    ),
 ) -> None:
-    """Sign in and choose which detected agents to configure."""
-    from .setup import setup_command
+    """Sign in and configure all detected agents (use --choose to pick individually)."""
+    from .core.setup_wizard import setup_command
 
-    setup_command(platform_url=url)
+    setup_command(platform_url=url, choose=choose)
 
 
 @app.command()
@@ -142,7 +147,7 @@ def connect(
     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
+    from .core.connect import connect_command
 
     connect_command(agent_name=agent, connect_all=all_agents)
 
@@ -153,7 +158,7 @@ def 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
+    from .core.disconnect import disconnect_command
 
     disconnect_command(agent_name=agent, disconnect_all=all_agents)
 
@@ -161,7 +166,7 @@ def disconnect(
 @app.command()
 def status() -> None:
     """Show registration and agent connection status."""
-    from .status import status_command
+    from .core.status import status_command
 
     status_command()
 
@@ -176,8 +181,8 @@ def set_path(
     """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
+    from ..infra.config import save_agent_path
+    from ..infra.paths import AgentName, agent_display_name
 
     try:
         display = agent_display_name(AgentName(agent))
@@ -200,8 +205,8 @@ 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
+    from ..infra.config import remove_agent_path
+    from ..infra.paths import AgentName, agent_display_name
 
     try:
         display = agent_display_name(AgentName(agent))
@@ -217,36 +222,64 @@ def clear_path(
 
 
 @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:
+def update(
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress non-error output"),
+    background: bool = typer.Option(
+        False,
+        "--background",
+        help="Start upgrade in background (integrations refresh on next run)",
+    ),
+    refresh_only: bool = typer.Option(
+        False,
+        "--refresh-only",
+        hidden=True,
+        help="Internal: refresh agent integrations at the current installed version",
+    ),
+) -> None:
+    """Upgrade agentnet-cli and refresh connected agent integrations."""
+    from .core.updater import clean_update, run_update  # noqa: PLC0415
+
+    if refresh_only:
+        result = clean_update(quiet=quiet, refresh_only=True)
+        if not quiet and result.refreshed:
+            console.print(f"  [green]✓[/green] Refreshed {result.refreshed} agent config(s)")
+        elif not quiet:
             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]")
+    if not quiet:
+        console.print()
+        console.print("  [dim]Checking PyPI for updates...[/dim]")
+
+    if background:
+        result = run_update(quiet=quiet, background=True, force=True)
     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]")
+        result = clean_update(quiet=quiet)
+
+    if quiet:
+        if result.message and not result.upgraded and not result.upgrade_started:
+            print(result.message, file=sys.stderr)
+        return
+
+    if result.upgrade_started:
+        console.print(f"  [green]✓[/green] {result.message}")
+        console.print("  [dim]Restart your agent to pick up the new version.[/dim]")
+    elif result.upgraded:
+        console.print(f"  [green]✓[/green] {result.message}")
+        console.print("  [dim]Agent integrations refreshed.[/dim]")
+    elif result.message and "failed" in result.message.lower():
+        console.print(f"  [red]✗[/red] {result.message}")
+        method = "pip install --upgrade agentnet-cli"
+        console.print(f"  [dim]Try manually: {method}[/dim]")
+    elif result.message == "Could not reach PyPI":
+        console.print("  [yellow]![/yellow] Could not reach PyPI — refreshing local configs only")
+    elif result.message:
+        console.print(f"  {result.message}")
+
+    if result.refreshed and not result.upgraded:
+        console.print(f"  [dim]Refreshed {result.refreshed} agent config(s).[/dim]")
+    elif result.checked and not result.upgraded and not result.upgrade_started and not result.refreshed:
+        console.print("  [dim]All agent configs are up to date.[/dim]")
 
     console.print()
 
@@ -254,22 +287,18 @@ def update() -> None:
 @app.command(name="mcp-serve", hidden=True)
 def mcp_serve() -> None:
     """Start the AgentNet MCP server (internal)."""
-    from .mcp.server import serve
+    from ..tools.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
+from .marketplace.agent import agent as _agent_fn  # noqa: E402
+from .marketplace.discover import agents as _agents_fn  # noqa: E402
+from .marketplace.discover import discover as _discover_fn  # noqa: E402
+from .marketplace.search import search as _search_fn  # noqa: E402
 
+app.command(name="search")(_search_fn)
 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/cli/marketplace/__init__.py

@@ -0,0 +1 @@
+"""Marketplace discovery commands (JSON output)."""