alphai 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

alphai/commands/orgs.py

@@ -0,0 +1,27 @@
+"""Organization commands for alphai CLI."""
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..client import AlphAIClient
+
+console = Console()
+
+
+@click.command()
+@click.pass_context
+def orgs(ctx: click.Context) -> None:
+    """List your organizations."""
+    client: AlphAIClient = ctx.obj['client']
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        task = progress.add_task("Fetching organizations...", total=None)
+        orgs_data = client.get_organizations()
+        progress.update(task, completed=1)
+    
+    client.display_organizations(orgs_data)

alphai/commands/projects.py

@@ -0,0 +1,35 @@
+"""Project commands for alphai CLI."""
+
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..client import AlphAIClient
+from ..config import Config
+
+console = Console()
+
+
+@click.command()
+@click.option('--org', help='Organization slug to filter by')
+@click.pass_context
+def projects(ctx: click.Context, org: Optional[str]) -> None:
+    """List your projects."""
+    client: AlphAIClient = ctx.obj['client']
+    config: Config = ctx.obj['config']
+    
+    # Use provided org or current org
+    org_id = org or config.current_org
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        task = progress.add_task("Fetching projects...", total=None)
+        projects_data = client.get_projects(org_id)
+        progress.update(task, completed=1)
+    
+    client.display_projects(projects_data)

alphai/config.py

@@ -11,10 +11,9 @@ from pydantic import BaseModel, Field
 class Config(BaseModel):
     """Configuration model for alphai CLI."""
     
-    api_url: str = Field(default="https://www.runalph.ai", description="API base URL")
+    api_url: str = Field(default="https://www.runalph.ai/api", description="API base URL")
     bearer_token: Optional[str] = Field(default=None, description="Bearer token for API authentication")
-    current_org: Optional[str] = Field(default=None, description="Current organization ID")
-    current_project: Optional[str] = Field(default=None, description="Current project ID")
+    current_org: Optional[str] = Field(default=None, description="Current organization slug")
     debug: bool = Field(default=False, description="Enable debug mode")
     
     @classmethod
@@ -80,9 +79,20 @@ class Config(BaseModel):
         self.bearer_token = None
         self.save()
     
+    @property
+    def base_url(self) -> str:
+        """Get the base URL (without /api suffix) for auth and frontend URLs."""
+        if self.api_url.endswith("/api"):
+            return self.api_url[:-4]
+        return self.api_url.rstrip("/")
+    
     def to_sdk_config(self) -> Dict[str, Any]:
-        """Convert to SDK configuration format."""
+        """Convert to SDK configuration format.
+        
+        Note: The SDK expects the base URL without /api suffix,
+        as it constructs paths like /api/orgs internally.
+        """
         return {
             "bearer_auth": self.bearer_token,
-            "server_url": self.api_url,
+            "server_url": self.base_url,
         } 

alphai/docker.py

@@ -8,6 +8,11 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.panel import Panel
 
+from .utils import get_logger
+from . import exceptions
+
+logger = get_logger(__name__)
+
 
 class DockerManager:
     """Manage Docker operations for the alphai CLI."""
@@ -22,8 +27,11 @@ class DockerManager:
         if self._docker_available is not None:
             return self._docker_available
         
+        logger.debug("Checking Docker availability")
+        
         # Check if docker command exists
         if not shutil.which("docker"):
+            logger.warning("Docker command not found in PATH")
             self._docker_available = False
             return False
         
@@ -36,8 +44,17 @@ class DockerManager:
                 timeout=10
             )
             self._docker_available = result.returncode == 0
+            if self._docker_available:
+                logger.info("Docker is available and running")
+            else:
+                logger.warning("Docker daemon is not running")
             return self._docker_available
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        except subprocess.TimeoutExpired:
+            logger.error("Docker info command timed out")
+            self._docker_available = False
+            return False
+        except subprocess.SubprocessError as e:
+            logger.error(f"Error checking Docker availability: {e}")
             self._docker_available = False
             return False
     
@@ -89,10 +106,12 @@ class DockerManager:
         command: Optional[str] = None
     ) -> Optional[Any]:
         """Run a Docker container with the specified configuration."""
+        logger.info(f"Starting container from image: {image}")
         if not self.is_docker_available():
+            logger.error("Cannot run container: Docker is not available")
             self.console.print("[red]Error: Docker is not available or not running[/red]")
             self.console.print("[yellow]Please install Docker and ensure it's running[/yellow]")
-            return None
+            raise exceptions.DockerNotAvailableError()
         
         # Build docker run command
         cmd = ["docker", "run"]
@@ -142,9 +161,11 @@ class DockerManager:
             )
             
             if not check_result.stdout.strip():
+                logger.info(f"Image {image} not found locally, pulling...")
                 self.console.print(f"[yellow]Image {image} not found locally, pulling...[/yellow]")
                 if not self.pull_image(image):
-                    return None
+                    logger.error(f"Failed to pull image: {image}")
+                    raise exceptions.DockerError(f"Failed to pull image: {image}")
             
             # Run the container
             if detach:
@@ -166,10 +187,12 @@ class DockerManager:
                 
                 if result.returncode == 0:
                     container_id = result.stdout.strip()
-                    return MockContainer(container_id)
+                    logger.info(f"Container started successfully: {container_id[:12]}")
+                    return ContainerHandle(container_id)
                 else:
+                    logger.error(f"Failed to start container: {result.stderr}")
                     self.console.print(f"[red]Error starting container: {result.stderr}[/red]")
-                    return None
+                    raise exceptions.ContainerError(f"Failed to start container: {result.stderr}")
             else:
                 # Interactive mode
                 self.console.print(f"[green]Starting interactive container from {image}...[/green]")
@@ -178,17 +201,21 @@ class DockerManager:
                 try:
                     # Run interactively without capturing output
                     result = subprocess.run(cmd)
-                    return MockContainer("interactive")
+                    return ContainerHandle("interactive")
                 except KeyboardInterrupt:
                     self.console.print("\n[yellow]Container stopped by user[/yellow]")
-                    return MockContainer("interactive")
+                    return ContainerHandle("interactive")
                 
         except subprocess.TimeoutExpired:
+            logger.error("Timeout starting container")
             self.console.print("[red]Timeout starting container[/red]")
-            return None
+            raise exceptions.TimeoutError("start container", 30)
+        except exceptions.DockerError:
+            raise
         except Exception as e:
+            logger.error(f"Unexpected error running container: {e}", exc_info=True)
             self.console.print(f"[red]Error running container: {e}[/red]")
-            return None
+            raise exceptions.ContainerError(f"Error running container: {e}")
     
     def list_containers(self, all_containers: bool = False) -> list:
         """List Docker containers."""
@@ -262,8 +289,9 @@ class DockerManager:
     
     def install_cloudflared_in_container(self, container_id: str) -> bool:
         """Install cloudflared in a running container."""
+        logger.info(f"Installing cloudflared in container {container_id[:12]}")
         if not self.is_docker_available():
-            return False
+            raise exceptions.DockerNotAvailableError()
         
         try:
             # Detect the container's package manager and architecture
@@ -271,8 +299,9 @@ class DockerManager:
             architecture = self._detect_architecture(container_id)
             
             if not package_manager:
+                logger.error(f"No compatible package manager found in container {container_id[:12]}")
                 self.console.print("[red]Unsupported container: No compatible package manager found[/red]")
-                return False
+                raise exceptions.CloudflaredError("No compatible package manager found")
             
             # Commands to install cloudflared based on package manager
             install_commands = self._get_install_commands(package_manager, architecture)
@@ -298,15 +327,20 @@ class DockerManager:
                     
                     progress.update(task, advance=1)
             
-            self.console.print("[green]✓ cloudflared installed successfully[/green]")
+            logger.info(f"Connector installed successfully in container {container_id[:12]}")
+            self.console.print("[green]✓ Connector installed[/green]")
             return True
             
         except subprocess.TimeoutExpired:
-            self.console.print("[red]Timeout installing cloudflared[/red]")
-            return False
+            logger.error(f"Timeout installing connector in container {container_id[:12]}")
+            self.console.print("[red]Timeout installing connector[/red]")
+            raise exceptions.TimeoutError("install connector", 60)
+        except exceptions.CloudflaredError:
+            raise
         except Exception as e:
-            self.console.print(f"[red]Error installing cloudflared: {e}[/red]")
-            return False
+            logger.error(f"Error installing connector: {e}", exc_info=True)
+            self.console.print(f"[red]Error installing connector: {e}[/red]")
+            raise exceptions.CloudflaredError(f"Failed to install connector: {e}")
     
     def _detect_package_manager(self, container_id: str) -> Optional[str]:
         """Detect the package manager available in the container."""
@@ -329,7 +363,7 @@ class DockerManager:
                 )
                 if result.returncode == 0:
                     return pm_name
-            except:
+            except Exception:
                 continue
         
         return None
@@ -353,7 +387,7 @@ class DockerManager:
                     'i386': '386'
                 }
                 return arch_map.get(arch, 'amd64')
-        except:
+        except Exception:
             pass
         
         return 'amd64'  # Default fallback
@@ -403,7 +437,7 @@ class DockerManager:
             ]
     
     def setup_tunnel_in_container(self, container_id: str, tunnel_token: str) -> bool:
-        """Set up cloudflared tunnel service in a running container."""
+        """Start cloudflared connector in container as a background process."""
         if not self.is_docker_available():
             return False
         
@@ -413,30 +447,30 @@ class DockerManager:
                 TextColumn("[progress.description]{task.description}"),
                 console=self.console
             ) as progress:
-                task = progress.add_task("Setting up tunnel service...", total=None)
+                task = progress.add_task("Establishing connection...", total=None)
                 
-                # Install the tunnel service with the token
+                # Run cloudflared in background (no service installation needed)
                 result = subprocess.run(
-                    ["docker", "exec", "--user", "root", container_id, "cloudflared", "service", "install", tunnel_token],
+                    ["docker", "exec", "-d", container_id, "cloudflared", "tunnel", "run", "--token", tunnel_token],
                     capture_output=True,
                     text=True,
-                    timeout=30
+                    timeout=10
                 )
                 
                 progress.update(task, completed=1)
             
             if result.returncode == 0:
-                self.console.print("[green]✓ Tunnel service installed successfully[/green]")
+                self.console.print("[green]✓ Connected[/green]")
                 return True
             else:
-                self.console.print(f"[red]Error setting up tunnel service: {result.stderr}[/red]")
+                self.console.print(f"[red]Error connecting: {result.stderr}[/red]")
                 return False
                 
         except subprocess.TimeoutExpired:
-            self.console.print("[red]Timeout setting up tunnel service[/red]")
+            self.console.print("[red]Connection timed out[/red]")
             return False
         except Exception as e:
-            self.console.print(f"[red]Error setting up tunnel service: {e}[/red]")
+            self.console.print(f"[red]Error connecting: {e}[/red]")
             return False
     
     def exec_command(self, container_id: str, command: str) -> Optional[str]:
@@ -643,8 +677,8 @@ class DockerManager:
         import secrets
         return secrets.token_hex(32)  # 64-character hex token
 
-    def uninstall_cloudflared_service(self, container_id: str) -> bool:
-        """Uninstall cloudflared service from a running container."""
+    def stop_cloudflared_in_container(self, container_id: str) -> bool:
+        """Stop cloudflared processes in a running container."""
         if not self.is_docker_available():
             return False
         
@@ -654,31 +688,32 @@ class DockerManager:
                 TextColumn("[progress.description]{task.description}"),
                 console=self.console
             ) as progress:
-                task = progress.add_task("Uninstalling cloudflared service...", total=None)
+                task = progress.add_task("Stopping cloudflared...", total=None)
                 
-                # Uninstall the cloudflared service
+                # Kill all cloudflared processes in the container
                 result = subprocess.run(
-                    ["docker", "exec", "--user", "root", container_id, "cloudflared", "service", "uninstall"],
+                    ["docker", "exec", container_id, "pkill", "-f", "cloudflared"],
                     capture_output=True,
                     text=True,
-                    timeout=30
+                    timeout=10
                 )
                 
                 progress.update(task, completed=1)
             
-            if result.returncode == 0:
-                self.console.print("[green]✓ Cloudflared service uninstalled successfully[/green]")
+            # pkill returns 0 if processes were found and killed, 1 if none found
+            if result.returncode in [0, 1]:
+                self.console.print("[green]✓ Connection closed[/green]")
                 return True
             else:
-                # Don't treat this as a hard error since the service might not be installed
-                self.console.print(f"[yellow]Warning: Could not uninstall cloudflared service: {result.stderr}[/yellow]")
+                # Don't treat this as a hard error
+                self.console.print(f"[yellow]Warning: Could not close connection: {result.stderr}[/yellow]")
                 return True
                 
         except subprocess.TimeoutExpired:
-            self.console.print("[yellow]Warning: Timeout uninstalling cloudflared service[/yellow]")
+            self.console.print("[yellow]Warning: Timeout closing connection[/yellow]")
             return True
         except Exception as e:
-            self.console.print(f"[yellow]Warning: Error uninstalling cloudflared service: {e}[/yellow]")
+            self.console.print(f"[yellow]Warning: Error closing connection: {e}[/yellow]")
             return True
 
     def stop_and_remove_container(self, container_id: str, force: bool = False) -> bool:
@@ -729,9 +764,9 @@ class DockerManager:
         try:
             # Check if container is running
             if self.is_container_running(container_id):
-                # Step 1: Uninstall cloudflared service if container is running
-                self.console.print("[yellow]Cleaning up cloudflared service...[/yellow]")
-                if not self.uninstall_cloudflared_service(container_id):
+                # Step 1: Stop connection service if container is running
+                self.console.print("[yellow]Closing connection...[/yellow]")
+                if not self.stop_cloudflared_in_container(container_id):
                     success = False
                 
                 # Give it a moment for the service to stop
@@ -755,10 +790,10 @@ class DockerManager:
             return False
 
 
-class MockContainer:
-    """Mock container object to simulate Docker container."""
+class ContainerHandle:
+    """Lightweight container reference returned from Docker operations."""
     
     def __init__(self, container_id: str):
-        """Initialize mock container."""
+        """Initialize container handle."""
         self.id = container_id
         self.short_id = container_id[:12] if len(container_id) > 12 else container_id 

alphai/exceptions.py

@@ -0,0 +1,122 @@
+"""Custom exceptions for alphai CLI."""
+
+from typing import Optional
+
+
+class AlphAIException(Exception):
+    """Base exception for all alphai errors."""
+    
+    def __init__(self, message: str, details: Optional[str] = None):
+        """Initialize exception with message and optional details."""
+        self.message = message
+        self.details = details
+        super().__init__(self.message)
+    
+    def __str__(self) -> str:
+        """String representation of the exception."""
+        if self.details:
+            return f"{self.message}\nDetails: {self.details}"
+        return self.message
+
+
+class AuthenticationError(AlphAIException):
+    """Raised when authentication fails."""
+    pass
+
+
+class AuthorizationError(AlphAIException):
+    """Raised when user lacks permissions for an operation."""
+    pass
+
+
+class APIError(AlphAIException):
+    """Raised when API request fails."""
+    
+    def __init__(self, message: str, status_code: Optional[int] = None, details: Optional[str] = None):
+        """Initialize API error with status code."""
+        self.status_code = status_code
+        super().__init__(message, details)
+    
+    def __str__(self) -> str:
+        """String representation including status code."""
+        base = super().__str__()
+        if self.status_code:
+            return f"{base} (Status: {self.status_code})"
+        return base
+
+
+class DockerError(AlphAIException):
+    """Raised when Docker operations fail."""
+    pass
+
+
+class DockerNotAvailableError(DockerError):
+    """Raised when Docker is not installed or not running."""
+    
+    def __init__(self):
+        super().__init__(
+            "Docker is not available or not running",
+            "Please install Docker and ensure it's running. Visit https://docs.docker.com/get-docker/"
+        )
+
+
+class ContainerError(DockerError):
+    """Raised when container operations fail."""
+    pass
+
+
+class TunnelError(AlphAIException):
+    """Raised when tunnel operations fail."""
+    pass
+
+
+class CloudflaredError(TunnelError):
+    """Raised when cloudflared operations fail."""
+    pass
+
+
+class ConfigurationError(AlphAIException):
+    """Raised when configuration is invalid."""
+    pass
+
+
+class ValidationError(AlphAIException):
+    """Raised when input validation fails."""
+    pass
+
+
+class NetworkError(AlphAIException):
+    """Raised when network operations fail."""
+    pass
+
+
+class TimeoutError(AlphAIException):
+    """Raised when an operation times out."""
+    
+    def __init__(self, operation: str, timeout_seconds: int):
+        """Initialize timeout error."""
+        super().__init__(
+            f"Operation '{operation}' timed out after {timeout_seconds} seconds",
+            "Try increasing the timeout or check your network connection"
+        )
+        self.operation = operation
+        self.timeout_seconds = timeout_seconds
+
+
+class ResourceNotFoundError(AlphAIException):
+    """Raised when a requested resource is not found."""
+    
+    def __init__(self, resource_type: str, resource_id: str):
+        """Initialize resource not found error."""
+        super().__init__(
+            f"{resource_type} '{resource_id}' not found",
+            f"Verify the {resource_type.lower()} ID is correct"
+        )
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+
+
+class JupyterError(AlphAIException):
+    """Raised when Jupyter operations fail."""
+    pass
+