ic-code 1.0.0__tar.gz → 1.0.2__tar.gz

{ic_code-1.0.0/src/ic_code.egg-info → ic_code-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ic-code
-Version: 1.0.0
+Version: 1.0.2
 Summary: Infrastructure CLI tool for managing AWS, CloudFlare, SSH, and more
 Home-page: https://github.com/dgr009/ic
 Author: SangYun Kim
@@ -99,14 +99,18 @@ IC CLI uses a modern YAML-based configuration system with separate files for def
 #### 1. Create Configuration Files
 
 ```bash
-# Copy example files
+# Copy example files (new preferred location)
+mkdir -p .ic/config
+cp .ic/config/secrets.yaml.example .ic/config/secrets.yaml
+
+# Or use legacy location for backward compatibility
 cp config/secrets.yaml.example config/secrets.yaml
 
 # Edit with your actual values
-vim config/secrets.yaml
+vim .ic/config/secrets.yaml
 ```
 
-#### 2. Configure Secrets (config/secrets.yaml)
+#### 2. Configure Secrets (~/.ic/config/secrets.yaml)
 
 ```yaml
 # AWS Configuration
@@ -139,7 +143,7 @@ oci:
   profile: "DEFAULT"
 ```
 
-#### 3. Default Settings (config/default.yaml)
+#### 3. Default Settings (.ic/config/default.yaml)
 
 The default configuration is already provided and includes:
 - AWS regions

{ic_code-1.0.0 → ic_code-1.0.2}/README.md

@@ -50,14 +50,18 @@ IC CLI uses a modern YAML-based configuration system with separate files for def
 #### 1. Create Configuration Files
 
 ```bash
-# Copy example files
+# Copy example files (new preferred location)
+mkdir -p .ic/config
+cp .ic/config/secrets.yaml.example .ic/config/secrets.yaml
+
+# Or use legacy location for backward compatibility
 cp config/secrets.yaml.example config/secrets.yaml
 
 # Edit with your actual values
-vim config/secrets.yaml
+vim .ic/config/secrets.yaml
 ```
 
-#### 2. Configure Secrets (config/secrets.yaml)
+#### 2. Configure Secrets (~/.ic/config/secrets.yaml)
 
 ```yaml
 # AWS Configuration
@@ -90,7 +94,7 @@ oci:
   profile: "DEFAULT"
 ```
 
-#### 3. Default Settings (config/default.yaml)
+#### 3. Default Settings (.ic/config/default.yaml)
 
 The default configuration is already provided and includes:
 - AWS regions

ic_code-1.0.2/aws/cloudfront/__init__.py

@@ -0,0 +1,16 @@
+"""
+AWS CloudFront module for distribution information and management.
+
+This module provides functionality to collect and display CloudFront distribution
+information including origins, domains, and price classes.
+"""
+
+__version__ = "1.0.0"
+__author__ = "IC Development Team"
+
+from .info import CloudFrontCollector, CloudFrontRenderer
+
+__all__ = [
+    "CloudFrontCollector",
+    "CloudFrontRenderer"
+]

ic_code-1.0.2/aws/cloudfront/info.py

@@ -0,0 +1,205 @@
+"""
+AWS CloudFront distribution information collector and renderer.
+
+This module provides classes to collect CloudFront distribution details
+and render them in a user-friendly table format.
+"""
+
+import boto3
+from typing import Dict, List, Any, Optional
+from rich.console import Console
+from rich.table import Table
+from botocore.exceptions import ClientError, NoCredentialsError
+
+import boto3
+
+
+class CloudFrontCollector:
+    """Collects CloudFront distribution information from AWS."""
+    
+    def __init__(self):
+        self.console = Console()
+    
+    def collect_distributions(self, account_profiles: Dict[str, str]) -> List[Dict[str, str]]:
+        """
+        Collect CloudFront distribution information from multiple accounts.
+        
+        Args:
+            account_profiles: Dictionary mapping account names to AWS profile names
+            
+        Returns:
+            List of distribution information dictionaries
+        """
+        from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+        import time
+        
+        distributions = []
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=self.console
+        ) as progress:
+            
+            # Create main task
+            main_task = progress.add_task(
+                f"Collecting CloudFront distributions from {len(account_profiles)} account(s)...",
+                total=len(account_profiles)
+            )
+            
+            for account_name, profile_name in account_profiles.items():
+                # Update task description
+                progress.update(main_task, description=f"Processing account: {account_name}")
+                
+                start_time = time.time()
+                try:
+                    session = boto3.Session(profile_name=profile_name)
+                    account_distributions = self._get_account_distributions(session, account_name)
+                    distributions.extend(account_distributions)
+                    
+                    # Calculate processing time
+                    processing_time = time.time() - start_time
+                    progress.console.print(
+                        f"✅ {account_name}: Found {len(account_distributions)} distributions "
+                        f"({processing_time:.2f}s)"
+                    )
+                    
+                except Exception as e:
+                    progress.console.print(f"❌ Failed to collect CloudFront data for {account_name}: {e}")
+                
+                # Advance progress
+                progress.advance(main_task)
+        
+        return distributions
+    
+    def _get_account_distributions(self, session: boto3.Session, account_name: str) -> List[Dict[str, str]]:
+        """
+        Get CloudFront distributions for a specific account.
+        
+        Args:
+            session: AWS session for the account
+            account_name: Name of the AWS account
+            
+        Returns:
+            List of distribution information dictionaries
+        """
+        try:
+            cloudfront_client = session.client('cloudfront')
+            
+            # List all distributions
+            response = cloudfront_client.list_distributions()
+            distributions = []
+            
+            if 'DistributionList' in response and 'Items' in response['DistributionList']:
+                for distribution in response['DistributionList']['Items']:
+                    dist_info = self.get_distribution_details(distribution, account_name)
+                    distributions.append(dist_info)
+            
+            return distributions
+            
+        except ClientError as e:
+            error_code = e.response['Error']['Code']
+            if error_code == 'AccessDenied':
+                self.console.print(f"⚠️  Access denied for CloudFront in {account_name}")
+            else:
+                self.console.print(f"❌ CloudFront API error in {account_name}: {e}")
+            return []
+        except NoCredentialsError:
+            self.console.print(f"❌ No credentials available for {account_name}")
+            return []
+    
+    def get_distribution_details(self, distribution: Dict[str, Any], account_name: str) -> Dict[str, str]:
+        """
+        Extract and format distribution details.
+        
+        Args:
+            distribution: CloudFront distribution data from AWS API
+            account_name: Name of the AWS account
+            
+        Returns:
+            Dictionary with formatted distribution information
+        """
+        return {
+            'account': account_name,
+            'ID': distribution.get('Id', 'N/A'),
+            'Name': distribution.get('Comment', 'N/A') or 'N/A',
+            '원본(Origin)': self.get_primary_origin(distribution.get('Origins', {}).get('Items', [])),
+            '도메인(Domain)': distribution.get('DomainName', 'N/A'),
+            'Class': self.format_price_class(distribution.get('PriceClass', 'PriceClass_All'))
+        }
+    
+    def get_primary_origin(self, origins: List[Dict[str, Any]]) -> str:
+        """
+        Get the primary origin or indicate multiple origins.
+        
+        Args:
+            origins: List of origin configurations
+            
+        Returns:
+            Primary origin domain or "Multiple" indicator
+        """
+        if not origins:
+            return 'N/A'
+        elif len(origins) == 1:
+            return origins[0].get('DomainName', 'N/A')
+        else:
+            return f'Multiple ({len(origins)})'
+    
+    def format_price_class(self, price_class: str) -> str:
+        """
+        Convert technical price class names to human-readable format.
+        
+        Args:
+            price_class: Technical price class name from AWS
+            
+        Returns:
+            Human-readable price class description
+        """
+        price_class_mapping = {
+            'PriceClass_All': 'All Edge Locations',
+            'PriceClass_200': 'North America and Europe Only',
+            'PriceClass_100': 'North America Only'
+        }
+        
+        return price_class_mapping.get(price_class, price_class)
+
+
+class CloudFrontRenderer:
+    """Renders CloudFront distribution information in table format."""
+    
+    def __init__(self):
+        self.console = Console()
+    
+    def render_distributions(self, distributions: List[Dict[str, str]]) -> None:
+        """
+        Render CloudFront distributions in a Rich table.
+        
+        Args:
+            distributions: List of distribution information dictionaries
+        """
+        if not distributions:
+            self.console.print("📋 No CloudFront distributions found.")
+            return
+        
+        table = Table(title="CloudFront Distributions")
+        table.add_column("Account", style="cyan", no_wrap=True)
+        table.add_column("ID", style="green", no_wrap=True)
+        table.add_column("Name", style="yellow")
+        table.add_column("원본(Origin)", style="blue")
+        table.add_column("도메인(Domain)", style="magenta")
+        table.add_column("Class", style="red")
+        
+        for dist in distributions:
+            table.add_row(
+                dist['account'],
+                dist['ID'],
+                dist['Name'],
+                dist['원본(Origin)'],
+                dist['도메인(Domain)'],
+                dist['Class']
+            )
+        
+        self.console.print(table)
+        self.console.print(f"\n📊 Total distributions: {len(distributions)}")

ic_code-1.0.2/aws/profile/__init__.py

@@ -0,0 +1,14 @@
+"""
+AWS Profile management module.
+
+This module provides functionality for parsing and displaying AWS profile information
+from ~/.aws/config and ~/.aws/credentials files.
+"""
+
+from .info import AWSProfileParser, ProfileInfoCollector, ProfileTableRenderer
+
+__all__ = [
+    'AWSProfileParser',
+    'ProfileInfoCollector', 
+    'ProfileTableRenderer'
+]

ic_code-1.0.2/aws/profile/info.py

@@ -0,0 +1,311 @@
+"""
+AWS profile information parser and renderer.
+
+This module provides classes to parse AWS configuration and credentials files
+and render profile information in a user-friendly table format.
+"""
+
+import os
+import re
+import configparser
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from rich.console import Console
+from rich.table import Table
+
+
+class AWSProfileParser:
+    """Parses AWS configuration and credentials files."""
+    
+    def __init__(self):
+        self.console = Console()
+        self.aws_config_path = Path.home() / ".aws" / "config"
+        self.aws_credentials_path = Path.home() / ".aws" / "credentials"
+    
+    def parse_config_file(self, config_path: Optional[str] = None) -> Dict[str, Dict[str, str]]:
+        """
+        Parse AWS config file (~/.aws/config).
+        
+        Args:
+            config_path: Optional path to config file
+            
+        Returns:
+            Dictionary of profile configurations
+        """
+        if config_path:
+            config_file = Path(config_path)
+        else:
+            config_file = self.aws_config_path
+        
+        if not config_file.exists():
+            self.console.print(f"⚠️  AWS config file not found: {config_file}")
+            return {}
+        
+        try:
+            config = configparser.ConfigParser()
+            config.read(config_file)
+            
+            profiles = {}
+            for section_name in config.sections():
+                # Handle both 'profile name' and 'name' formats
+                if section_name.startswith('profile '):
+                    profile_name = section_name[8:]  # Remove 'profile ' prefix
+                else:
+                    profile_name = section_name
+                
+                profile_data = dict(config[section_name])
+                profiles[profile_name] = profile_data
+            
+            return profiles
+            
+        except Exception as e:
+            self.console.print(f"❌ Failed to parse AWS config file: {e}")
+            return {}
+    
+    def parse_credentials_file(self, creds_path: Optional[str] = None) -> Dict[str, Dict[str, str]]:
+        """
+        Parse AWS credentials file (~/.aws/credentials).
+        
+        Args:
+            creds_path: Optional path to credentials file
+            
+        Returns:
+            Dictionary of profile credentials
+        """
+        if creds_path:
+            creds_file = Path(creds_path)
+        else:
+            creds_file = self.aws_credentials_path
+        
+        if not creds_file.exists():
+            self.console.print(f"⚠️  AWS credentials file not found: {creds_file}")
+            return {}
+        
+        try:
+            config = configparser.ConfigParser()
+            config.read(creds_file)
+            
+            credentials = {}
+            for section_name in config.sections():
+                profile_data = dict(config[section_name])
+                credentials[section_name] = profile_data
+            
+            return credentials
+            
+        except Exception as e:
+            self.console.print(f"❌ Failed to parse AWS credentials file: {e}")
+            return {}
+    
+    def extract_account_from_role_arn(self, role_arn: str) -> Optional[str]:
+        """
+        Extract account ID from role ARN.
+        
+        Args:
+            role_arn: AWS role ARN (e.g., arn:aws:iam::123456789012:role/RoleName)
+            
+        Returns:
+            Account ID or None if not found
+        """
+        if not role_arn:
+            return None
+        
+        # Pattern: arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME
+        arn_pattern = r'arn:aws:iam::(\d{12}):role/'
+        match = re.search(arn_pattern, role_arn)
+        
+        if match:
+            return match.group(1)
+        
+        return None
+    
+    def extract_role_name_from_arn(self, role_arn: str) -> Optional[str]:
+        """
+        Extract role name from role ARN (last part after final slash).
+        
+        Args:
+            role_arn: AWS role ARN
+            
+        Returns:
+            Role name or None if not found
+        """
+        if not role_arn:
+            return None
+        
+        # Extract everything after the last slash
+        parts = role_arn.split('/')
+        if len(parts) > 1:
+            return parts[-1]
+        
+        return None
+
+
+class ProfileInfoCollector:
+    """Collects and formats AWS profile information."""
+    
+    def __init__(self):
+        self.parser = AWSProfileParser()
+        self.console = Console()
+    
+    def collect_profile_info(self) -> List[Dict[str, str]]:
+        """
+        Collect comprehensive AWS profile information.
+        
+        Returns:
+            List of profile information dictionaries
+        """
+        from rich.progress import Progress, SpinnerColumn, TextColumn
+        import time
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console
+        ) as progress:
+            
+            # Parse config file
+            task = progress.add_task("Parsing AWS configuration files...", total=None)
+            start_time = time.time()
+            
+            config_data = self.parser.parse_config_file()
+            progress.update(task, description="Parsing AWS credentials file...")
+            
+            creds_data = self.parser.parse_credentials_file()
+            progress.update(task, description="Merging profile information...")
+            
+            # Merge and format profile information
+            profiles = self.merge_config_and_credentials(config_data, creds_data)
+            
+            # Calculate processing time
+            processing_time = time.time() - start_time
+            progress.update(task, description=f"Completed in {processing_time:.2f}s")
+            progress.stop()
+        
+        return profiles
+    
+    def merge_config_and_credentials(self, config_data: Dict[str, Dict[str, str]], 
+                                   creds_data: Dict[str, Dict[str, str]]) -> List[Dict[str, str]]:
+        """
+        Merge configuration and credentials data into unified profile information.
+        
+        Args:
+            config_data: Data from ~/.aws/config
+            creds_data: Data from ~/.aws/credentials
+            
+        Returns:
+            List of merged profile information
+        """
+        profiles = []
+        
+        # Get all unique profile names
+        all_profiles = set(config_data.keys()) | set(creds_data.keys())
+        
+        for profile_name in sorted(all_profiles):
+            config_info = config_data.get(profile_name, {})
+            creds_info = creds_data.get(profile_name, {})
+            
+            # Extract profile information
+            profile_info = {
+                'profile_name': profile_name,
+                'account_id': self._extract_account_id(config_info, creds_info),
+                'source': config_info.get('source_profile', ''),
+                'role_name': self._extract_role_name(config_info),
+                'credential': 'active' if creds_info else 'inactive',
+                'region': config_info.get('region', ''),
+                'role_arn': config_info.get('role_arn', '')
+            }
+            
+            profiles.append(profile_info)
+        
+        return profiles
+    
+    def _extract_account_id(self, config_info: Dict[str, str], creds_info: Dict[str, str]) -> str:
+        """Extract account ID from various sources."""
+        # Try direct account_id first
+        if 'account_id' in config_info:
+            return config_info['account_id']
+        
+        # Try extracting from role_arn
+        if 'role_arn' in config_info:
+            account_id = self.parser.extract_account_from_role_arn(config_info['role_arn'])
+            if account_id:
+                return account_id
+        
+        # Try from credentials (less common)
+        if 'account_id' in creds_info:
+            return creds_info['account_id']
+        
+        return ''
+    
+    def _extract_role_name(self, config_info: Dict[str, str]) -> str:
+        """Extract role name from configuration."""
+        if 'role_arn' in config_info:
+            role_name = self.parser.extract_role_name_from_arn(config_info['role_arn'])
+            if role_name:
+                return role_name
+        
+        # Fallback to role_name if directly specified
+        return config_info.get('role_name', '')
+
+
+class ProfileTableRenderer:
+    """Renders AWS profile information in table format using Rich."""
+    
+    def __init__(self):
+        self.console = Console()
+    
+    def render_profiles(self, profiles: List[Dict[str, str]]) -> None:
+        """
+        Render AWS profiles in a Rich table.
+        
+        Args:
+            profiles: List of profile information dictionaries
+        """
+        if not profiles:
+            self.console.print("📋 No AWS profiles found.")
+            self.console.print("\n💡 Suggestions:")
+            self.console.print("  • Check if ~/.aws/config and ~/.aws/credentials files exist")
+            self.console.print("  • Run 'aws configure' to set up your first profile")
+            self.console.print("  • Verify AWS CLI installation")
+            return
+        
+        table = Table(title="AWS Profiles")
+        table.add_column("Profile Name", style="cyan", no_wrap=True)
+        table.add_column("Account ID", style="green", no_wrap=True)
+        table.add_column("Source", style="yellow")
+        table.add_column("Role Name", style="blue")
+        table.add_column("Credential", style="magenta")
+        table.add_column("Region", style="red")
+        
+        for profile in profiles:
+            # Format credential status with colors
+            credential_status = profile['credential']
+            if credential_status == 'active':
+                credential_display = f"[green]{credential_status}[/green]"
+            else:
+                credential_display = f"[red]{credential_status}[/red]"
+            
+            table.add_row(
+                profile['profile_name'],
+                profile['account_id'] or '-',
+                profile['source'] or '-',
+                profile['role_name'] or '-',
+                credential_display,
+                profile['region'] or '-'
+            )
+        
+        self.console.print(table)
+        
+        # Display summary
+        active_profiles = sum(1 for p in profiles if p['credential'] == 'active')
+        self.console.print(f"\n📊 Total profiles: {len(profiles)} | Active: {active_profiles} | Inactive: {len(profiles) - active_profiles}")
+        
+        # Display helpful information
+        if active_profiles == 0:
+            self.console.print("\n⚠️  No active profiles found (no credentials available)")
+            self.console.print("💡 Run 'aws configure' to set up credentials for your profiles")
+        
+        # Show profiles with missing account IDs
+        missing_accounts = [p['profile_name'] for p in profiles if not p['account_id']]
+        if missing_accounts:
+            self.console.print(f"\n⚠️  Profiles without account ID: {', '.join(missing_accounts)}")
+            self.console.print("💡 Consider adding role_arn or account_id to these profiles")

{ic_code-1.0.0 → ic_code-1.0.2}/cf/dns/list_info.py

@@ -162,7 +162,7 @@ def info(args):
     """
     # 인증 정보 검사
     if not CF_EMAIL or not CF_TOKEN:
-        log_error("CloudFlare 인증 정보가 설정되지 않았습니다. config/secrets.yaml을 확인하세요.")
+        log_error("CloudFlare 인증 정보가 설정되지 않았습니다. .ic/config/secrets.yaml 또는 config/secrets.yaml을 확인하세요.")
         return
 
     env_accounts = []