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

alphai/client.py

@@ -9,6 +9,10 @@ from rich.panel import Panel
 from rich.text import Text
 
 from .config import Config
+from .utils import get_logger
+from . import exceptions
+
+logger = get_logger(__name__)
 
 
 class TunnelData:
@@ -41,31 +45,52 @@ class AlphAIClient:
         """Get the SDK instance, creating it if necessary."""
         if self._sdk is None:
             if not self.config.bearer_token:
+                logger.error("SDK initialization failed: No authentication token")
                 self.console.print("[red]Error: No authentication token found. Please run 'alphai login' first.[/red]")
-                sys.exit(1)
+                raise exceptions.AuthenticationError("No authentication token found")
             
-            self._sdk = AlphSDK(**self.config.to_sdk_config())
+            try:
+                self._sdk = AlphSDK(**self.config.to_sdk_config())
+                logger.debug("SDK initialized successfully")
+            except Exception as e:
+                logger.error(f"Failed to initialize SDK: {e}")
+                raise exceptions.APIError(f"Failed to initialize SDK: {e}")
         return self._sdk
     
     def test_connection(self) -> bool:
         """Test the connection to the API."""
         try:
+            logger.info("Testing API connection")
             # Try to get organizations as a connection test
             response = self.sdk.orgs.get()
-            return response.result.status == "success" if response.result.status else True
+            success = response.result.status == "success" if response.result.status else True
+            if success:
+                logger.info("API connection test successful")
+            else:
+                logger.warning("API connection test failed: unexpected response")
+            return success
+        except exceptions.AuthenticationError:
+            raise
         except Exception as e:
+            logger.error(f"Connection test failed: {e}", exc_info=True)
             self.console.print(f"[red]Connection test failed: {e}[/red]")
-            return False
+            raise exceptions.NetworkError(f"Connection test failed: {e}")
     
     def get_organizations(self) -> List[Dict[str, Any]]:
         """Get all organizations."""
         try:
+            logger.debug("Fetching organizations from API")
             response = self.sdk.orgs.get()
             # Access organizations from response.result.organizations
-            return response.result.organizations or []
+            orgs = response.result.organizations or []
+            logger.info(f"Successfully fetched {len(orgs)} organization(s)")
+            return orgs
+        except exceptions.AuthenticationError:
+            raise
         except Exception as e:
+            logger.error(f"Error getting organizations: {e}", exc_info=True)
             self.console.print(f"[red]Error getting organizations: {e}[/red]")
-            return []
+            raise exceptions.APIError(f"Failed to get organizations: {e}")
     
     def create_organization(self, name: str, description: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """Create a new organization."""
@@ -109,15 +134,13 @@ class AlphAIClient:
         table.add_column("Name", style="green")
         table.add_column("Role", style="blue")
         table.add_column("Slug", style="dim")
-        table.add_column("Subscription", style="yellow")
         
         for org in orgs:
             table.add_row(
                 org.id or "",
                 org.name or "",
                 org.role or "",
-                org.slug or "",
-                org.subscription_level or ""
+                org.slug or ""
             )
         
         self.console.print(table)
@@ -155,27 +178,53 @@ class AlphAIClient:
         """Display current configuration status."""
         status_info = []
         
-        # API URL
-        status_info.append(f"[bold]API URL:[/bold] {self.config.api_url}")
+        # Only show API URL if it's not the default (for developers using custom endpoints)
+        default_api_url = "https://www.runalph.ai/api"
+        if self.config.api_url != default_api_url:
+            status_info.append(f"[bold]API:[/bold] {self.config.api_url} [dim](custom)[/dim]")
         
-        # Authentication status
+        # Authentication status and user info
         if self.config.bearer_token:
             status_info.append("[bold]Authentication:[/bold] [green]✓ Logged in[/green]")
+            
+            # Try to fetch organizations to show helpful context
+            try:
+                orgs = self.get_organizations()
+                if orgs:
+                    # Show current/default organization
+                    if self.config.current_org:
+                        # Find the org name for the current org slug
+                        current_org_name = None
+                        for org in orgs:
+                            if hasattr(org, 'slug') and org.slug == self.config.current_org:
+                                current_org_name = org.name
+                                break
+                        if current_org_name:
+                            status_info.append(f"[bold]Organization:[/bold] {current_org_name} [dim]({self.config.current_org})[/dim]")
+                        else:
+                            status_info.append(f"[bold]Organization:[/bold] {self.config.current_org}")
+                    elif len(orgs) == 1:
+                        # If only one org, show it as the default
+                        org = orgs[0]
+                        status_info.append(f"[bold]Organization:[/bold] {org.name} [dim]({org.slug})[/dim]")
+                    else:
+                        # Multiple orgs, show count and list them
+                        status_info.append(f"[bold]Organizations:[/bold] {len(orgs)} available")
+                        for org in orgs[:3]:  # Show up to 3
+                            # Handle role which may be an enum or string
+                            role_str = ""
+                            if hasattr(org, 'role') and org.role:
+                                role_val = org.role.value if hasattr(org.role, 'value') else str(org.role)
+                                role_str = f"[cyan]{role_val}[/cyan]"
+                            status_info.append(f"  • {org.name} [dim]({org.slug})[/dim] {role_str}")
+                        if len(orgs) > 3:
+                            status_info.append(f"  [dim]... and {len(orgs) - 3} more[/dim]")
+            except Exception:
+                # Silently fail if we can't fetch orgs - just don't show org info
+                pass
         else:
             status_info.append("[bold]Authentication:[/bold] [red]✗ Not logged in[/red]")
         
-        # Current organization
-        if self.config.current_org:
-            status_info.append(f"[bold]Current Organization:[/bold] {self.config.current_org}")
-        else:
-            status_info.append("[bold]Current Organization:[/bold] [dim]None selected[/dim]")
-        
-        # Current project
-        if self.config.current_project:
-            status_info.append(f"[bold]Current Project:[/bold] {self.config.current_project}")
-        else:
-            status_info.append("[bold]Current Project:[/bold] [dim]None selected[/dim]")
-        
         # Debug mode
         if self.config.debug:
             status_info.append("[bold]Debug Mode:[/bold] [yellow]Enabled[/yellow]")
@@ -186,6 +235,18 @@ class AlphAIClient:
             title_align="left"
         )
         self.console.print(panel)
+        
+        # Show helpful tips based on state
+        if not self.config.bearer_token:
+            self.console.print("\n[bold yellow]Quick Start:[/bold yellow]")
+            self.console.print("  [cyan]alphai login[/cyan]         Log in to runalph.ai")
+            self.console.print("  [cyan]alphai login --browser[/cyan] Log in via browser (recommended)")
+        else:
+            self.console.print("\n[bold yellow]Quick Start:[/bold yellow]")
+            self.console.print("  [cyan]alphai jupyter lab[/cyan]   Start Jupyter Lab with cloud sync")
+            self.console.print("  [cyan]alphai nb[/cyan]       List your notebooks")
+            self.console.print("  [cyan]alphai orgs[/cyan]     List your organizations")
+            self.console.print("  [cyan]alphai --help[/cyan]        Show all commands")
     
     def create_tunnel(
         self, 
@@ -205,40 +266,38 @@ class AlphAIClient:
             
             if response.result.status == "success":
                 tunnel_data = response.result.data
-                self.console.print(f"[green]✓ Tunnel created successfully[/green]")
-                self.console.print(f"[blue]Tunnel ID: {tunnel_data.id}[/blue]")
-                self.console.print(f"[blue]App URL: {tunnel_data.app_url}[/blue]")
-                self.console.print(f"[blue]Jupyter URL: {tunnel_data.jupyter_url}[/blue]")
+                logger.info(f"Connection created: {tunnel_data.id}")
                 return tunnel_data
             else:
-                self.console.print(f"[red]Failed to create tunnel: {response.result.status}[/red]")
+                self.console.print(f"[red]Failed to connect: {response.result.status}[/red]")
                 return None
         except Exception as e:
-            self.console.print(f"[red]Error creating tunnel: {e}[/red]")
+            self.console.print(f"[red]Error connecting: {e}[/red]")
             return None
     
     def get_tunnel(self, tunnel_id: str) -> Optional[Dict[str, Any]]:
-        """Get tunnel information by ID."""
+        """Get connection information by ID."""
         try:
             response = self.sdk.tunnels.get(tunnel_id=tunnel_id)
             return response.result.data if response.result.status == "success" else None
         except Exception as e:
-            self.console.print(f"[red]Error getting tunnel: {e}[/red]")
+            logger.error(f"Error getting connection: {e}")
             return None
     
     def delete_tunnel(self, tunnel_id: str) -> bool:
-        """Delete a tunnel by ID."""
+        """Delete a connection by ID."""
         try:
+            logger.info(f"Cleaning up connection: {tunnel_id}")
             response = self.sdk.tunnels.delete(tunnel_id=tunnel_id)
             if response.result.status == "success":
-                self.console.print(f"[green]✓ Tunnel {tunnel_id} deleted successfully[/green]")
+                logger.info(f"Connection {tunnel_id} cleaned up successfully")
                 return True
             else:
-                self.console.print(f"[red]Failed to delete tunnel: {response.result.status}[/red]")
+                logger.warning(f"Failed to clean up connection {tunnel_id}: {response.result.status}")
                 return False
         except Exception as e:
-            self.console.print(f"[red]Error deleting tunnel: {e}[/red]")
-            return False
+            logger.error(f"Error cleaning up connection {tunnel_id}: {e}", exc_info=True)
+            raise exceptions.TunnelError(f"Failed to clean up connection: {e}")
     
     def create_project(
         self, 
@@ -275,14 +334,21 @@ class AlphAIClient:
     def get_organization_by_slug(self, slug: str) -> Optional[Dict[str, Any]]:
         """Get organization by slug."""
         try:
+            logger.debug(f"Looking up organization by slug: {slug}")
             orgs = self.get_organizations()
             for org in orgs:
                 if hasattr(org, 'slug') and org.slug == slug:
+                    logger.info(f"Found organization: {slug}")
                     return org
-            return None
+            logger.warning(f"Organization not found: {slug}")
+            raise exceptions.ResourceNotFoundError("Organization", slug)
+        except exceptions.ResourceNotFoundError:
+            self.console.print(f"[red]Organization '{slug}' not found[/red]")
+            raise
         except Exception as e:
+            logger.error(f"Error getting organization by slug: {e}", exc_info=True)
             self.console.print(f"[red]Error getting organization by slug: {e}[/red]")
-            return None
+            raise
     
     def create_tunnel_with_project(
         self, 
@@ -325,24 +391,8 @@ class AlphAIClient:
         # Store project data in wrapper
         wrapped_tunnel.project_data = project_data
         
-        # Enhanced logging output
-        self.console.print("\n[bold green]🎉 Tunnel and Project Setup Complete![/bold green]")
-        self.console.print(f"[bold]Tunnel ID:[/bold] {wrapped_tunnel.id}")
-        if project_data:
-            self.console.print(f"[bold]Project ID:[/bold] {project_data.id if hasattr(project_data, 'id') else 'Created'}")
-        
-        # Token information
-        self.console.print(f"\n[bold]Cloudflared Token:[/bold]")
-        self.console.print(f"[dim]For tunnel setup: cloudflared service install {wrapped_tunnel.cloudflared_token}[/dim]")
-        
-        if jupyter_token:
-            self.console.print(f"\n[bold]Jupyter Token:[/bold]")
-            self.console.print(f"[dim]For Jupyter access: {jupyter_token}[/dim]")
-        
-        # URLs
-        self.console.print(f"\n[bold]Access URLs:[/bold]")
-        self.console.print(f"[blue]• App URL: {wrapped_tunnel.app_url}[/blue]")
-        self.console.print(f"[blue]• Jupyter URL: {wrapped_tunnel.jupyter_url}[/blue]")
+        # Log success (user-facing details shown by caller)
+        logger.info(f"Project setup complete: {project_name}")
         
         return wrapped_tunnel
     
@@ -358,13 +408,13 @@ class AlphAIClient:
         try:
             response = self.sdk.projects.delete(project_id=project_id)
             if response.result.status == "success":
-                self.console.print(f"[green]✓ Project {project_id} deleted successfully[/green]")
+                logger.info(f"Project {project_id} deleted successfully")
                 return True
             else:
-                self.console.print(f"[red]Failed to delete project: {response.result.status}[/red]")
+                logger.warning(f"Failed to delete project: {response.result.status}")
                 return False
         except Exception as e:
-            self.console.print(f"[red]Error deleting project: {e}[/red]")
+            logger.error(f"Error deleting project: {e}")
             return False
 
     def cleanup_tunnel_and_project(
@@ -373,28 +423,23 @@ class AlphAIClient:
         project_id: Optional[str] = None,
         force: bool = False
     ) -> bool:
-        """Comprehensive cleanup of tunnel and project resources."""
+        """Comprehensive cleanup of connection and project resources."""
         success = True
         
         if not tunnel_id and not project_id:
-            self.console.print("[yellow]No tunnel or project ID provided for cleanup[/yellow]")
+            logger.debug("No resources to clean up")
             return True
         
-        # Delete tunnel first
+        # Clean up connection first
         if tunnel_id:
-            self.console.print(f"[yellow]Deleting tunnel {tunnel_id}...[/yellow]")
+            logger.info(f"Cleaning up connection...")
             if not self.delete_tunnel(tunnel_id):
                 success = False
         
         # Delete project second  
         if project_id:
-            self.console.print(f"[yellow]Deleting project {project_id}...[/yellow]")
+            logger.info(f"Cleaning up project...")
             if not self.delete_project(project_id):
                 success = False
         
-        if success:
-            self.console.print("[green]✓ Tunnel and project cleanup completed successfully[/green]")
-        else:
-            self.console.print("[yellow]⚠ Tunnel and project cleanup completed with errors[/yellow]")
-        
         return success 

alphai/commands/__init__.py

@@ -0,0 +1,24 @@
+"""Command modules for alphai CLI.
+
+This package contains the CLI commands organized by domain:
+- jupyter: Jupyter Lab/Notebook commands
+- docker: Docker container management (run, cleanup)
+- orgs: Organization listing
+- projects: Project listing
+- config: Configuration management
+"""
+
+from .jupyter import jupyter
+from .docker import run, cleanup
+from .orgs import orgs
+from .projects import projects
+from .config import config
+
+__all__ = [
+    'jupyter',
+    'run',
+    'cleanup',
+    'orgs',
+    'projects',
+    'config',
+]

alphai/commands/config.py

@@ -0,0 +1,67 @@
+"""Configuration commands for alphai CLI."""
+
+import sys
+
+import click
+from rich.console import Console
+from rich.prompt import Confirm
+
+from ..client import AlphAIClient
+from ..config import Config as ConfigModel
+
+console = Console()
+
+
+@click.group()
+@click.pass_context
+def config(ctx: click.Context) -> None:
+    """Manage configuration settings."""
+    pass
+
+
+@config.command('show')
+@click.pass_context
+def config_show(ctx: click.Context) -> None:
+    """Show current configuration."""
+    client: AlphAIClient = ctx.obj['client']
+    client.display_status()
+
+
+@config.command('set')
+@click.argument('key')
+@click.argument('value')
+@click.pass_context
+def config_set(ctx: click.Context, key: str, value: str) -> None:
+    """Set a configuration value."""
+    cfg: ConfigModel = ctx.obj['config']
+    
+    valid_keys = {'api_url', 'debug', 'current_org'}
+    
+    if key not in valid_keys:
+        console.print(f"[red]Invalid configuration key. Valid keys: {', '.join(valid_keys)}[/red]")
+        sys.exit(1)
+    
+    # Convert string values to appropriate types
+    if key == 'debug':
+        value = value.lower() in ('true', '1', 'yes', 'on')
+    
+    setattr(cfg, key, value)
+    cfg.save()
+    console.print(f"[green]✓ Set {key} = {value}[/green]")
+
+
+@config.command('reset')
+@click.pass_context
+def config_reset(ctx: click.Context) -> None:
+    """Reset configuration to defaults."""
+    if Confirm.ask("Are you sure you want to reset all configuration to defaults?"):
+        config_file = ConfigModel.get_config_file()
+        if config_file.exists():
+            config_file.unlink()
+        
+        # Clear keyring
+        cfg = ConfigModel()
+        cfg.clear_bearer_token()
+        
+        console.print("[green]✓ Configuration reset to defaults[/green]")
+