Merge pull request #12 from mtpontes/release/2.0.1

fix: default command and config proxy

Author: mtpontes

pyproject.toml

@@ -40,6 +40,19 @@ clean = [
     "rm -rf dist build *.egg-info"
 ]
 
+[tool.hatch.envs.test]
+dependencies = [
+    "pytest",
+    "pytest-cov",
+    "testcontainers[localstack]",
+    "moto[s3,athena,sts]",
+    "requests",
+]
+
+[tool.hatch.envs.test.scripts]
+run = "pytest {args:tests}"
+cov = "pytest --cov=src --cov-report=term-missing {args:tests}"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src"]
 
@@ -60,3 +73,8 @@ select = ["E", "W", "F"]
 [tool.ruff.lint.isort]
 force-wrap-aliases = true
 split-on-trailing-comma = true
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore:The wait_for_logs function with string or callable predicates is deprecated:DeprecationWarning:testcontainers.localstack",
+]

src/cli/cli.py

@@ -63,6 +63,7 @@
     compare_entry,
     sync_entry,
     git_hook_entry,
+    dashboard_entry,
 )
 
 
@@ -71,6 +72,7 @@
     name="workstate",
     help="Portable development environment management tool",
     add_completion=False,
+    no_args_is_help=True,
     context_settings={"help_option_names": ["-h", "--help"]},
 )
 
@@ -123,3 +125,4 @@ def global_callback(
 compare_entry.register(app, console, state_service, file_service)
 sync_entry.register(app, console, state_service, file_service)
 git_hook_entry.register(app, console, hook_svc)
+dashboard_entry.register(app, console)

src/cli/dashboard_entry.py

@@ -0,0 +1,65 @@
+import typer
+from rich.console import Console
+from pathlib import Path
+from src.services import state_service, dashboard_service
+from src.utils.utils import handle_error
+from src.services.config_service import ConfigService
+
+def register(app: typer, console: Console):
+    @app.command("dashboard", help="Generates and uploads an S3 dashboard HTML")
+    def dashboard(
+        open_browser: bool = typer.Option(True, "--open", help="Open the dashboard in browser after upload"),
+    ) -> None:
+        """Generates a standalone HTML dashboard of your S3 bucket states and uploads it.
+        
+        The dashboard includes:
+        - Visualization of all project states
+        - Total disk usage statistics
+        - Search and filtering capabilities
+        """
+        try:
+            with console.status("[bold green]Fetching bucket data...", spinner="dots"):
+                states = state_service.list_states(global_scan=True, use_cache=False)
+                credentials = ConfigService.get_aws_credentials()
+                bucket_name = credentials.bucket_name
+            
+            if not states:
+                console.print("[yellow]No states found in bucket to generate dashboard.[/yellow]")
+                return
+
+            with console.status("[bold blue]Generating HTML Dashboard...", spinner="dots"):
+                html_content = dashboard_service.DashboardService.generate_dashboard_html(states, bucket_name)
+                
+                # Write to temp file
+                from tempfile import NamedTemporaryFile
+                with NamedTemporaryFile(suffix=".html", delete=False, mode="w", encoding="utf-8") as tmp:
+                    tmp.write(html_content)
+                    tmp_path = Path(tmp.name)
+            
+            with console.status("[bold magenta]Uploading to S3...", spinner="dots"):
+                from src.clients import s3_client
+                s3 = s3_client.create_s3_resource()
+                # Upload to index.html at root (or a dedicated reports/ folder)
+                target_key = "dashboard.html"
+                s3.upload_file(str(tmp_path), target_key, ExtraArgs={'ContentType': 'text/html'})
+                
+                # Generate a pre-signed URL for temporary access
+                s3_client_raw = s3_client.create_s3_client()
+                url = s3_client_raw.generate_presigned_url(
+                    'get_object',
+                    Params={'Bucket': bucket_name, 'Key': target_key},
+                    ExpiresIn=3600 # 1 hour
+                )
+
+            console.print(f"\n[green][OK] Dashboard generated and uploaded to {bucket_name}/{target_key}[/green]")
+            console.print(f"[bold cyan]Access URL (Valid for 1 hour):[/bold cyan]\n{url}\n")
+            
+            if open_browser:
+                import webbrowser
+                webbrowser.open(url)
+                
+            # Cleanup
+            tmp_path.unlink()
+
+        except Exception as e:
+            handle_error(console, e)

src/cli/download_entry.py

@@ -19,6 +19,9 @@ def download_state(
         yes_to_hooks: bool = typer.Option(
             False, "--yes-to-hooks", "-y", help="Execute post-restore hooks without confirmation"
         ),
+        path_filters: list[str] = typer.Option(
+            None, "--path", help="Specific files or directories to restore (glob patterns supported)"
+        ),
     ) -> None:
         """Restores a saved project state from AWS S3
 
@@ -57,6 +60,7 @@ def download_state(
                 state_service=state_service,
                 hook_service=hook_service,
                 yes_to_hooks=yes_to_hooks,
+                path_filters=path_filters,
             ).execute()
         except Exception as e:
             handle_error(console, e)

src/cli/list_entry.py

@@ -17,6 +17,7 @@ def list_state_zips(
         interactive: bool = typer.Option(
             False, "--interactive", "-i", help="Interactive mode with fuzzy search"
         ),
+        use_cache: bool = typer.Option(True, "--cache/--no-cache", help="Use local metadata cache (default: True)"),
     ) -> None:
         """Lists all project states available in AWS S3
 
@@ -50,7 +51,8 @@ def list_state_zips(
                 interactive=interactive,
                 system_filter=system,
                 branch_filter=branch,
-                older_than_filter=older_than
+                older_than_filter=older_than,
+                use_cache=use_cache
             ).execute()
         except Exception as e:
             handle_error(console, e)

src/clients/s3_client.py

@@ -5,37 +5,121 @@
 
 from src.services.config_service import ConfigService
 from src.model.dto.aws_credentials_dto import AWSCredentialsDTO
+from src.exception.credentials_validation_exception import CredentialsValidationException
+
+
+def validate_credentials(require_bucket: bool = True):
+    """Public validation of credentials before creating S3/STS clients."""
+    credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    errors = {}
+    if not credentials.access_key_id:
+        errors["access_key_id"] = "Access Key ID is missing"
+    if not credentials.secret_access_key:
+        errors["secret_access_key"] = "Secret Access Key is missing"
+    if require_bucket and not credentials.bucket_name:
+        errors["bucket_name"] = "S3 Bucket Name is missing"
+    
+    if errors:
+        raise CredentialsValidationException(errors)
 
 
 def create_s3_resource() -> Bucket:
     """Creates S3 resource with proper configuration"""
     credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    validate_credentials()
+    
     s3_resource = boto3.resource(
         "s3",
         aws_access_key_id=credentials.access_key_id,
         aws_secret_access_key=credentials.secret_access_key,
         region_name=credentials.region,
+        endpoint_url=getattr(credentials, "endpoint_url", None),
     )
     return s3_resource.Bucket(credentials.bucket_name)
 
 
 def create_s3_client() -> S3Client:
     """Creates S3 resource with proper configuration"""
     credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    validate_credentials()
+    
     return boto3.client(
         "s3",
         aws_access_key_id=credentials.access_key_id,
         aws_secret_access_key=credentials.secret_access_key,
         region_name=credentials.region,
+        endpoint_url=getattr(credentials, "endpoint_url", None),
     )
 
 
 def create_sts_client():
     """Creates STS client for identity verification"""
     credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    validate_credentials(require_bucket=False)
+    
     return boto3.client(
         "sts",
         aws_access_key_id=credentials.access_key_id,
         aws_secret_access_key=credentials.secret_access_key,
         region_name=credentials.region,
     )
+
+
+def create_bucket(bucket_name: str, region: str) -> None:
+    """Creates an S3 bucket with the specified name and region."""
+    credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    client = boto3.client(
+        "s3",
+        aws_access_key_id=credentials.access_key_id,
+        aws_secret_access_key=credentials.secret_access_key,
+        region_name=region,
+        endpoint_url=getattr(credentials, "endpoint_url", None),
+    )
+    
+    if region == "us-east-1":
+        client.create_bucket(Bucket=bucket_name)
+    else:
+        client.create_bucket(
+            Bucket=bucket_name,
+            CreateBucketConfiguration={"LocationConstraint": region},
+        )
+
+
+def put_public_access_block(bucket_name: str, region: str) -> None:
+    """Configures public access block for the bucket."""
+    credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    client = boto3.client(
+        "s3",
+        aws_access_key_id=credentials.access_key_id,
+        aws_secret_access_key=credentials.secret_access_key,
+        region_name=region,
+        endpoint_url=getattr(credentials, "endpoint_url", None),
+    )
+    client.put_public_access_block(
+        Bucket=bucket_name,
+        PublicAccessBlockConfiguration={
+            "BlockPublicAcls": True,
+            "IgnorePublicAcls": True,
+            "BlockPublicPolicy": True,
+            "RestrictPublicBuckets": True,
+        },
+    )
+
+
+def list_workstate_buckets() -> list[str]:
+    """Lists all S3 buckets that match the Workstate prefix."""
+    credentials: AWSCredentialsDTO = ConfigService.get_aws_credentials()
+    client = boto3.client(
+        "s3",
+        aws_access_key_id=credentials.access_key_id,
+        aws_secret_access_key=credentials.secret_access_key,
+        region_name=credentials.region,
+        endpoint_url=getattr(credentials, "endpoint_url", None),
+    )
+    
+    try:
+        response = client.list_buckets()
+        buckets = [b["Name"] for b in response.get("Buckets", [])]
+        return [b for b in buckets if b.startswith("workstate-storage-")]
+    except Exception:
+        return []

src/commands/command.py

@@ -3,5 +3,5 @@
 
 class CommandI(ABC):
     @abstractmethod
-    def execute() -> None:
+    def execute(self) -> None:
         pass

src/commands/compare_command.py

@@ -50,7 +50,7 @@ def execute(self) -> None:
 
         diff_found = any(res["status"] != "EQUAL" for res in results)
         if not diff_found:
-            self.console.print(f"\n[bold green]✔ Local project matches {self.state_name} perfectly.[/bold green]")
+            self.console.print(f"\n[bold green][OK] Local project matches {self.state_name} perfectly.[/bold green]")
             return
 
         table = compare_view.compare_results_table(self.state_name, results)

src/commands/configure_command.py

@@ -53,12 +53,52 @@ def execute(self) -> None:
 
         if self.interactive:
             credentials: AWSCredentialsDTO = self.prompter.prompt(self.credentials)
+        else:
+            credentials: AWSCredentialsDTO = self.credentials
 
         self._save_credentials(credentials)
 
+        # Check if bucket exists and offer to create it
+        if self.interactive:
+            self._check_and_create_bucket(credentials)
+        
+        # Add to history for future configuration ease
+        ConfigService.add_to_bucket_history(credentials.bucket_name)
+
         self.console.print(f"Configuration saved to: {ConfigService.CONFIG_FILE}")
         self.console.print("[green]✓ AWS credentials configured successfully![/green]\n")
 
+    def _check_and_create_bucket(self, credentials: AWSCredentialsDTO) -> None:
+        from src.clients import s3_client
+        from botocore.exceptions import ClientError
+        
+        bucket_name = credentials.bucket_name
+        region = credentials.region
+        
+        try:
+            # Check if bucket exists and is accessible
+            # Note: We must create a client with THE NEW credentials just provided
+            # S3resource factory uses ConfigService which we just updated
+            s3_resource = s3_client.create_s3_resource()
+            s3_resource.meta.client.head_bucket(Bucket=bucket_name)
+            self.console.print(f"[green][OK] Bucket '{bucket_name}' already exists and is accessible.[/green]")
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code")
+            # 404 means not found, 403 means forbidden (might exist but no access)
+            if error_code == "404":
+                self.console.print(f"\n[yellow]⚠ Bucket '{bucket_name}' does not exist.[/yellow]")
+                if typer.confirm(f"Would you like to create bucket '{bucket_name}' in region '{region}'?", default=True):
+                    with self.console.status(f"[bold green]Creating bucket {bucket_name}...", spinner="dots"):
+                        s3_client.create_bucket(bucket_name, region)
+                        s3_client.put_public_access_block(bucket_name, region)
+                    self.console.print(f"[green][OK] Bucket '{bucket_name}' created successfully with public access blocked.[/green]")
+            elif error_code == "403":
+                self.console.print(f"[red]✖ Access denied to bucket '{bucket_name}'. Please check your permissions.[/red]")
+            else:
+                self.console.print(f"[red]✖ Error checking bucket: {str(e)}[/red]")
+        except Exception as e:
+            self.console.print(f"[red]✖ Unexpected error while checking bucket: {str(e)}[/red]")
+
     def _save_credentials(self, credentials: AWSCredentialsDTO) -> None:
         validated_credentials: AWSCredentials = None
         try:

src/commands/delete_command.py

@@ -3,6 +3,7 @@
 from src.services import state_service
 from src.commands.command import CommandI
 from src.prompts.zip_file_selector_prompter import ZipFileSelectorPrompter
+from src.clients import s3_client
 
 
 class DeleteCommandImpl(CommandI):
@@ -17,6 +18,7 @@ def __init__(
         self.state_service = state_service
 
     def execute(self) -> None:
+        s3_client.validate_credentials()
         selected_zip_file: str = self.prompter.prompt(message="Select a zip file to delete:")
 
         with self.console.status("[bold green]Deleting state...", spinner="dots"):