connectonion 0.5.8__py3-none-any.whl

connectonion/cli/commands/deploy_commands.py

@@ -0,0 +1,220 @@
+"""
+Purpose: Deploy agent projects to ConnectOnion Cloud with git archive packaging and secrets management
+LLM-Note:
+  Dependencies: imports from [os, subprocess, tempfile, time, toml, requests, pathlib, rich.console, dotenv] | imported by [cli/main.py via handle_deploy()] | calls backend at [https://oo.openonion.ai/api/v1/deploy]
+  Data flow: handle_deploy() → validates git repo and .co/config.toml → _get_api_key() loads OPENONION_API_KEY → reads config.toml for project name and secrets path → dotenv_values() loads secrets from .env → git archive creates tarball of HEAD → POST to /api/v1/deploy with tarball + project_name + secrets → polls /api/v1/deploy/{id}/status until running/error → displays agent URL
+  State/Effects: creates temporary tarball file in tempdir | reads .co/config.toml, .env files | makes network POST request | prints progress to stdout via rich.Console | does not modify project files
+  Integration: exposes handle_deploy() for CLI | expects git repo with .co/config.toml containing project.name, project.secrets, deploy.entrypoint | uses Bearer token auth | returns void (prints results)
+  Performance: git archive is fast | network timeout 600s for upload+build, 10s for status checks | polls every 3s up to 100 times (~5 min)
+  Errors: fails if not git repo | fails if not ConnectOnion project (.co/config.toml missing) | fails if no API key | prints backend error messages
+"""
+
+import json
+import os
+import re
+import subprocess
+import tempfile
+import time
+import toml
+import requests
+from pathlib import Path
+from rich.console import Console
+from dotenv import dotenv_values, load_dotenv
+
+console = Console()
+
+API_BASE = "https://oo.openonion.ai"
+
+
+def _check_host_export(entrypoint: str) -> bool:
+    """Check if entrypoint file exports an ASGI app via host().
+
+    Looks for patterns like:
+    - host(agent)
+    - host(my_agent)
+    - from connectonion import host
+    """
+    entrypoint_path = Path(entrypoint)
+    if not entrypoint_path.exists():
+        return False
+
+    content = entrypoint_path.read_text()
+
+    # Check for host() call pattern
+    # Matches: host(agent), host(my_agent), host( agent ), etc.
+    host_call_pattern = r'\bhost\s*\([^)]+\)'
+
+    if re.search(host_call_pattern, content):
+        return True
+
+    return False
+
+
+def _get_api_key() -> str:
+    """Get OPENONION_API_KEY from env or .env files."""
+    if api_key := os.getenv("OPENONION_API_KEY"):
+        return api_key
+
+    for env_path in [Path(".env"), Path.home() / ".co" / "keys.env"]:
+        if env_path.exists():
+            load_dotenv(env_path)
+            if api_key := os.getenv("OPENONION_API_KEY"):
+                return api_key
+    return None
+
+
+def handle_deploy():
+    """Deploy agent to ConnectOnion Cloud."""
+    console.print("\n[cyan]Deploying to ConnectOnion Cloud...[/cyan]\n")
+
+    project_dir = Path.cwd()
+
+    # Must be a git repo
+    if not (project_dir / ".git").exists():
+        console.print("[red]Not a git repository. Run 'git init' first.[/red]")
+        return
+
+    # Must be a ConnectOnion project
+    config_path = Path(".co") / "config.toml"
+    if not config_path.exists():
+        console.print("[red]Not a ConnectOnion project. Run 'co init' first.[/red]")
+        return
+
+    # Must have API key
+    api_key = _get_api_key()
+    if not api_key:
+        console.print("[red]No API key. Run 'co auth' first.[/red]")
+        return
+
+    config = toml.load(config_path)
+    project_name = config.get("project", {}).get("name", "unnamed-agent")
+    secrets_path = config.get("project", {}).get("secrets", ".env")
+    entrypoint = config.get("deploy", {}).get("entrypoint", "agent.py")
+
+    # Validate entrypoint exists
+    if not Path(entrypoint).exists():
+        console.print(f"[red]Entrypoint not found: {entrypoint}[/red]")
+        console.print("[dim]Set entrypoint in .co/config.toml under [deploy][/dim]")
+        return
+
+    # Validate entrypoint exports ASGI app via host()
+    if not _check_host_export(entrypoint):
+        console.print(f"[red]Entrypoint '{entrypoint}' does not export an ASGI app.[/red]")
+        console.print()
+        console.print("[yellow]To deploy, your agent must call host():[/yellow]")
+        console.print()
+        console.print("  [cyan]from connectonion import Agent, host[/cyan]")
+        console.print()
+        console.print("  [cyan]agent = Agent('my-agent', ...)[/cyan]")
+        console.print("  [cyan]host(agent)  # Starts HTTP server[/cyan]")
+        console.print()
+        console.print("[dim]See: https://docs.connectonion.com/deploy[/dim]")
+        return
+
+    # Load secrets from .env
+    secrets = dotenv_values(secrets_path) if Path(secrets_path).exists() else {}
+
+    # Create tarball from git
+    tarball_path = Path(tempfile.mkdtemp()) / "agent.tar.gz"
+    subprocess.run(
+        ["git", "archive", "--format=tar.gz", "-o", str(tarball_path), "HEAD"],
+        cwd=project_dir,
+        check=True,
+    )
+
+    # Show package size
+    tarball_size = tarball_path.stat().st_size
+    if tarball_size < 1024:
+        size_str = f"{tarball_size} B"
+    elif tarball_size < 1024 * 1024:
+        size_str = f"{tarball_size / 1024:.1f} KB"
+    else:
+        size_str = f"{tarball_size / (1024 * 1024):.2f} MB"
+
+    console.print(f"  Project: {project_name}")
+    console.print(f"  Package: {size_str}")
+    console.print(f"  Secrets: {len(secrets)} keys")
+    console.print()
+
+    # Upload
+    console.print("Uploading...")
+    with open(tarball_path, "rb") as f:
+        response = requests.post(
+            f"{API_BASE}/api/v1/deploy",
+            files={"package": ("agent.tar.gz", f, "application/gzip")},
+            data={
+                "project_name": project_name,
+                "secrets": json.dumps(secrets),
+                "entrypoint": entrypoint,
+            },
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=600,  # 10 minutes for docker build
+        )
+
+    if response.status_code != 200:
+        console.print(f"[red]Deploy failed: {response.text}[/red]")
+        return
+
+    result = response.json()
+
+    # Check for error response (backend returns 200 with error dict)
+    if "error" in result:
+        console.print(f"[red]Deploy failed: {result['error']}[/red]")
+        return
+
+    deployment_id = result.get("id")
+    url = result.get("url", "")
+
+    # Wait for deployment
+    console.print("Building...")
+    deploy_success = False
+    final_status = "unknown"
+    timeout_count = 0
+
+    for _ in range(100):
+        try:
+            status_resp = requests.get(
+                f"{API_BASE}/api/v1/deploy/{deployment_id}/status",
+                headers={"Authorization": f"Bearer {api_key}"},
+                timeout=30,  # Increased timeout for slow SSH
+            )
+        except requests.exceptions.Timeout:
+            timeout_count += 1
+            if timeout_count >= 3:
+                console.print("[yellow]Status checks timing out, but deploy may still succeed.[/yellow]")
+                break
+            time.sleep(3)
+            continue
+        except requests.exceptions.RequestException as e:
+            console.print(f"[yellow]Network error: {e}[/yellow]")
+            time.sleep(3)
+            continue
+
+        if status_resp.status_code != 200:
+            console.print(f"[red]Status check failed: {status_resp.status_code}[/red]")
+            break
+
+        result = status_resp.json()
+        final_status = result.get("status", "unknown")
+
+        if final_status == "running":
+            deploy_success = True
+            # Update URL from status response (may be more up-to-date)
+            url = result.get("url") or url
+            break
+        if final_status in ("error", "failed"):
+            console.print(f"[red]Deploy failed: {result.get('error_message', 'Unknown error')}[/red]")
+            return
+        time.sleep(3)
+
+    console.print()
+    if deploy_success:
+        console.print("[bold green]Deployed![/bold green]")
+    else:
+        console.print(f"[yellow]Deploy status: {final_status}[/yellow]")
+        console.print("[yellow]Check status with 'co deployments' or try again.[/yellow]")
+
+    # Always show URL if we have one
+    if url:
+        console.print(f"Agent URL: {url}")
+    console.print()

connectonion/cli/commands/doctor_commands.py

@@ -0,0 +1,173 @@
+"""
+Purpose: Diagnose ConnectOnion installation and configuration issues
+LLM-Note:
+  Dependencies: imports from [sys, os, shutil, pathlib, requests, rich.console, rich.panel, rich.table, __version__] | imported by [cli/main.py via handle_doctor()] | checks local files and backend connectivity
+  Data flow: receives no args → checks system info → checks config files → checks API key → tests backend connectivity → displays results with ✓/✗ indicators
+  State/Effects: no state modifications | reads from filesystem | makes HTTP request | writes to stdout via rich.Console
+  Integration: exposes handle_doctor() for CLI | helps users self-diagnose setup issues
+  Performance: fast local checks (<100ms) | network check to backend (1-2s)
+  Errors: lets errors crash naturally - no try-except unless absolutely needed
+"""
+
+import sys
+import os
+import shutil
+from pathlib import Path
+import requests
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+console = Console()
+
+
+def handle_doctor():
+    """Run comprehensive diagnostics on ConnectOnion installation."""
+    from ... import __version__
+
+    console.print("\n[bold cyan]🔍 ConnectOnion Diagnostics[/bold cyan]\n")
+
+    # System checks
+    system_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+    system_table.add_column("Check", style="cyan")
+    system_table.add_column("Status")
+
+    # Version
+    system_table.add_row("Version", f"[green]✓[/green] {__version__}")
+
+    # Python
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    python_path = sys.executable
+    system_table.add_row("Python", f"[green]✓[/green] {python_version}")
+    system_table.add_row("Python Path", f"[dim]{python_path}[/dim]")
+
+    # Virtual environment
+    in_venv = hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix)
+    venv_status = "[green]✓[/green] Virtual environment" if in_venv else "[yellow]○[/yellow] Global Python"
+    system_table.add_row("Environment", venv_status)
+    if in_venv:
+        system_table.add_row("Venv Path", f"[dim]{sys.prefix}[/dim]")
+
+    # Command location
+    co_path = shutil.which('co')
+    if co_path:
+        system_table.add_row("Command", f"[green]✓[/green] {co_path}")
+    else:
+        system_table.add_row("Command", "[red]✗[/red] 'co' not found in PATH")
+
+    # Package location
+    import connectonion
+    package_path = Path(connectonion.__file__).parent
+    system_table.add_row("Package", f"[dim]{package_path}[/dim]")
+
+    console.print(Panel(system_table, title="[bold]System[/bold]", border_style="blue"))
+    console.print()
+
+    # Configuration checks
+    config_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+    config_table.add_column("Check", style="cyan")
+    config_table.add_column("Status")
+
+    # Check for config.toml
+    local_config = Path(".co") / "config.toml"
+    global_config = Path.home() / ".co" / "config.toml"
+
+    if local_config.exists():
+        config_table.add_row("Config", f"[green]✓[/green] {local_config}")
+        import toml
+        config = toml.load(local_config)
+        agent_name = config.get("agent", {}).get("name", "Not set")
+        config_table.add_row("Agent Name", f"[dim]{agent_name}[/dim]")
+    elif global_config.exists():
+        config_table.add_row("Config", f"[green]✓[/green] {global_config}")
+    else:
+        config_table.add_row("Config", "[yellow]○[/yellow] Not found (optional)")
+
+    # Check for keys
+    local_keys = Path(".co") / "keys" / "agent.key"
+    global_keys = Path.home() / ".co" / "keys" / "agent.key"
+
+    if local_keys.exists():
+        config_table.add_row("Keys", f"[green]✓[/green] {local_keys}")
+    elif global_keys.exists():
+        config_table.add_row("Keys", f"[green]✓[/green] {global_keys}")
+    else:
+        config_table.add_row("Keys", "[yellow]○[/yellow] Not found (run 'co auth' to create)")
+
+    # Check for API key
+    api_key = os.getenv("OPENONION_API_KEY")
+    if api_key:
+        api_key_display = f"{api_key[:20]}..." if len(api_key) > 20 else api_key
+        config_table.add_row("API Key", f"[green]✓[/green] Found in environment")
+        config_table.add_row("Key Preview", f"[dim]{api_key_display}[/dim]")
+    else:
+        # Check .env files
+        from dotenv import load_dotenv
+        local_env = Path(".env")
+        global_env = Path.home() / ".co" / "keys.env"
+
+        if local_env.exists():
+            load_dotenv(local_env)
+            api_key = os.getenv("OPENONION_API_KEY")
+            if api_key:
+                config_table.add_row("API Key", f"[green]✓[/green] Found in .env")
+
+        if not api_key and global_env.exists():
+            load_dotenv(global_env)
+            api_key = os.getenv("OPENONION_API_KEY")
+            if api_key:
+                config_table.add_row("API Key", f"[green]✓[/green] Found in ~/.co/keys.env")
+
+        if not api_key:
+            config_table.add_row("API Key", "[yellow]○[/yellow] Not configured (run 'co auth')")
+
+    console.print(Panel(config_table, title="[bold]Configuration[/bold]", border_style="green"))
+    console.print()
+
+    # Connectivity checks (only if API key exists)
+    if api_key:
+        connectivity_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+        connectivity_table.add_column("Check", style="cyan")
+        connectivity_table.add_column("Status")
+
+        # Check backend reachability
+        response = requests.get("https://oo.openonion.ai/health", timeout=5)
+        if response.status_code == 200:
+            connectivity_table.add_row("Backend", "[green]✓[/green] https://oo.openonion.ai")
+        else:
+            connectivity_table.add_row("Backend", f"[yellow]⚠[/yellow] Status {response.status_code}")
+
+        # Check authentication (if keys exist)
+        if local_keys.exists() or global_keys.exists():
+            from ... import address
+            import time
+
+            co_dir = Path(".co") if local_keys.exists() else Path.home() / ".co"
+            addr_data = address.load(co_dir)
+
+            public_key = addr_data["address"]
+            timestamp = int(time.time())
+            message = f"ConnectOnion-Auth-{public_key}-{timestamp}"
+            signature = address.sign(addr_data, message.encode()).hex()
+
+            response = requests.post(
+                "https://oo.openonion.ai/api/v1/auth",
+                json={
+                    "public_key": public_key,
+                    "signature": signature,
+                    "message": message
+                },
+                timeout=5
+            )
+
+            if response.status_code == 200:
+                connectivity_table.add_row("Authentication", "[green]✓[/green] Valid credentials")
+            else:
+                connectivity_table.add_row("Authentication", f"[red]✗[/red] Failed (status {response.status_code})")
+
+        console.print(Panel(connectivity_table, title="[bold]Connectivity[/bold]", border_style="magenta"))
+        console.print()
+
+    console.print("[bold green]✅ Diagnostics complete![/bold green]\n")
+    console.print("[dim]Run 'co auth' if you need to authenticate[/dim]\n")