cloudx-proxy 0.1.1__tar.gz → 0.3.0__tar.gz

cloudx_proxy-0.3.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# [0.3.0](https://github.com/easytocloud/cloudX-proxy/compare/v0.2.0...v0.3.0) (2025-02-09)
+
+
+### Bug Fixes
+
+* improve SSH key message and config header ([94dd9b6](https://github.com/easytocloud/cloudX-proxy/commit/94dd9b6bd42b2b23e2e732470adf0096aa98e0fb))
+* improve UI formatting and progress tracking ([570a0de](https://github.com/easytocloud/cloudX-proxy/commit/570a0deab309f42ee8c961062596189f8d5d6a91))
+* only include non-default parameters in ProxyCommand ([e1ecae9](https://github.com/easytocloud/cloudX-proxy/commit/e1ecae9fd91ae1bbed92d60ed384a0e405269a35))
+* simplify setup UI and improve error handling ([613cba3](https://github.com/easytocloud/cloudX-proxy/commit/613cba3596c5631d7125c814f0f829c7171ff529))
+* update branding to cloudx-proxy ([b354d84](https://github.com/easytocloud/cloudX-proxy/commit/b354d84d99005d11f51212ce70d40c0d36ea47dd))
+
+
+### Features
+
+* add status indicators to instance setup check ([dfb3624](https://github.com/easytocloud/cloudX-proxy/commit/dfb36240583b46a54742306f9eae24e592d65fbe))
+* enhance setup UI with progress bar, colors, and summary ([f72efd1](https://github.com/easytocloud/cloudX-proxy/commit/f72efd175c7805cfd41605f33d5056e714911972))
+* extract default env from IAM user and improve SSH config handling ([25fa9c9](https://github.com/easytocloud/cloudX-proxy/commit/25fa9c976d4ae992e5217680405cd407e613eac3))
+
+# [0.2.0](https://github.com/easytocloud/cloudX-proxy/compare/v0.1.1...v0.2.0) (2025-02-09)
+
+
+### Features
+
+* add setup checklist and make all steps optional ([46016b8](https://github.com/easytocloud/cloudX-proxy/commit/46016b8fd7f1a1ae42fb34a7ff35365279883ab0))
+
+## [0.1.1](https://github.com/easytocloud/cloudX-proxy/compare/v0.1.0...v0.1.1) (2025-02-09)
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0](https://github.com/easytocloud/cloudX-proxy/releases/tag/v0.1.0) (2025-02-09)
+
+Initial release with core functionality:
+
+### Features
+
+* SSH proxy command for connecting VSCode to EC2 instances via SSM
+* AWS profile configuration with cloudX-{env}-{user} format
+* SSH key management with 1Password integration
+* Environment-specific SSH config generation
+* Instance setup status verification
+* Cross-platform support (Windows, macOS, Linux)
+* Automatic instance startup if stopped
+* SSH key distribution via EC2 Instance Connect
+* SSH tunneling through AWS Systems Manager

{cloudx_proxy-0.1.1 → cloudx_proxy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cloudx-proxy
-Version: 0.1.1
+Version: 0.3.0
 Summary: SSH proxy command to connect VSCode with Cloud9/CloudX instance using AWS Systems Manager
 Author-email: easytocloud <info@easytocloud.com>
 License: MIT License

{cloudx_proxy-0.1.1 → cloudx_proxy-0.3.0}/cloudx_proxy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

{cloudx_proxy-0.1.1 → cloudx_proxy-0.3.0}/cloudx_proxy/cli.py

@@ -16,9 +16,9 @@ def cli():
 @click.argument('port', type=int, default=22)
 @click.option('--profile', default='vscode', help='AWS profile to use (default: vscode)')
 @click.option('--region', help='AWS region (default: from profile, or eu-west-1 if not set)')
-@click.option('--key-path', help='Path to SSH public key (default: ~/.ssh/vscode/vscode.pub)')
+@click.option('--ssh-key', default='vscode', help='SSH key name to use (default: vscode)')
 @click.option('--aws-env', help='AWS environment directory (default: ~/.aws, use name of directory in ~/.aws/aws-envs/)')
-def connect(instance_id: str, port: int, profile: str, region: str, key_path: str, aws_env: str):
+def connect(instance_id: str, port: int, profile: str, region: str, ssh_key: str, aws_env: str):
     """Connect to an EC2 instance via SSM.
     
     INSTANCE_ID is the EC2 instance ID to connect to (e.g., i-0123456789abcdef0)
@@ -34,7 +34,7 @@ def connect(instance_id: str, port: int, profile: str, region: str, key_path: st
             port=port,
             profile=profile,
             region=region,
-            public_key_path=key_path,
+            ssh_key=ssh_key,
             aws_env=aws_env
         )
         
@@ -65,6 +65,8 @@ def setup(profile: str, ssh_key: str, aws_env: str):
     try:
         setup = CloudXSetup(profile=profile, ssh_key=ssh_key, aws_env=aws_env)
         
+        print("\n\033[1;95m=== cloudx-proxy Setup ===\033[0m\n")
+        
         # Set up AWS profile
         if not setup.setup_aws_profile():
             sys.exit(1)
@@ -73,10 +75,10 @@ def setup(profile: str, ssh_key: str, aws_env: str):
         if not setup.setup_ssh_key():
             sys.exit(1)
         
-        # Get CloudX environment and instance details
-        cloudx_env = click.prompt("Enter CloudX environment (e.g., dev, prod)", type=str)
-        instance_id = click.prompt("Enter EC2 instance ID (e.g., i-0123456789abcdef0)", type=str)
-        hostname = click.prompt("Enter hostname for the instance", type=str)
+        # Get environment and instance details
+        cloudx_env = setup.prompt("Enter environment", getattr(setup, 'default_env', None))
+        instance_id = setup.prompt("Enter EC2 instance ID (e.g., i-0123456789abcdef0)")
+        hostname = setup.prompt("Enter hostname for the instance")
         
         # Set up SSH config
         if not setup.setup_ssh_config(cloudx_env, instance_id, hostname):
@@ -86,7 +88,7 @@ def setup(profile: str, ssh_key: str, aws_env: str):
         setup.wait_for_setup_completion(instance_id)
         
     except Exception as e:
-        print(f"Error: {str(e)}", file=sys.stderr)
+        print(f"\n\033[91mError: {str(e)}\033[0m", file=sys.stderr)
         sys.exit(1)
 
 if __name__ == '__main__':

cloudx_proxy-0.3.0/cloudx_proxy/setup.py

@@ -0,0 +1,524 @@
+import os
+import time
+import json
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple
+import boto3
+from botocore.exceptions import ClientError
+
+class CloudXSetup:
+    def __init__(self, profile: str = "vscode", ssh_key: str = "vscode", aws_env: str = None):
+        """Initialize cloudx-proxy setup.
+        
+        Args:
+            profile: AWS profile name (default: "vscode")
+            ssh_key: SSH key name (default: "vscode")
+            aws_env: AWS environment directory (default: None)
+        """
+        self.profile = profile
+        self.ssh_key = ssh_key
+        self.aws_env = aws_env
+        self.home_dir = str(Path.home())
+        self.ssh_dir = Path(self.home_dir) / ".ssh" / "vscode"
+        self.ssh_config_file = self.ssh_dir / "config"
+        self.ssh_key_file = self.ssh_dir / f"{ssh_key}"
+        self.using_1password = False
+        self.default_env = None
+
+    def print_header(self, text: str) -> None:
+        """Print a section header.
+        
+        Args:
+            text: The header text
+        """
+        print(f"\n\n\033[1;94m=== {text} ===\033[0m")
+
+    def print_status(self, message: str, status: bool = None, indent: int = 0) -> None:
+        """Print a status message with optional checkmark/cross.
+        
+        Args:
+            message: The message to print
+            status: True for success (✓), False for failure (✗), None for no symbol
+            indent: Number of spaces to indent
+        """
+        prefix = " " * indent
+        if status is not None:
+            symbol = "✓" if status else "✗"
+            color = "\033[92m" if status else "\033[91m"  # Green for success, red for failure
+            reset = "\033[0m"
+            print(f"{prefix}{color}{symbol}{reset} {message}")
+        else:
+            print(f"{prefix}○ {message}")
+
+    def prompt(self, message: str, default: str = None) -> str:
+        """Display a colored prompt for user input.
+        
+        Args:
+            message: The prompt message
+            default: Default value (shown in brackets)
+        
+        Returns:
+            str: User's input or default value
+        """
+        if default:
+            prompt_text = f"\033[93m{message} [{default}]: \033[0m"
+        else:
+            prompt_text = f"\033[93m{message}: \033[0m"
+        response = input(prompt_text)
+        return response if response else default
+
+    def setup_aws_profile(self) -> bool:
+        """Set up AWS profile using aws configure command.
+        
+        Returns:
+            bool: True if profile was set up successfully or user chose to continue
+        """
+        self.print_status("Checking AWS profile configuration...")
+        
+        try:
+            # Configure AWS environment if specified
+            if self.aws_env:
+                aws_env_dir = os.path.expanduser(f"~/.aws/aws-envs/{self.aws_env}")
+                os.environ["AWS_CONFIG_FILE"] = os.path.join(aws_env_dir, "config")
+                os.environ["AWS_SHARED_CREDENTIALS_FILE"] = os.path.join(aws_env_dir, "credentials")
+
+            # Try to create session with profile
+            try:
+                session = boto3.Session(profile_name=self.profile)
+            except:
+                # Profile doesn't exist, create it
+                self.print_status(f"AWS profile '{self.profile}' not found", False, 2)
+                self.print_status("Setting up AWS profile...", None, 2)
+                print("\033[96mPlease enter your AWS credentials:\033[0m")
+                
+                # Use aws configure command
+                subprocess.run([
+                    'aws', 'configure',
+                    '--profile', self.profile
+                ], check=True)
+                
+                # Create new session with configured profile
+                session = boto3.Session(profile_name=self.profile)
+
+            # Verify the profile works
+            try:
+                identity = session.client('sts').get_caller_identity()
+                user_arn = identity['Arn']
+                
+                # Extract environment from IAM user name
+                user_parts = [part for part in user_arn.split('/') if part.startswith('cloudX-')]
+                if user_parts:
+                    self.default_env = user_parts[0].split('-')[1]  # Extract env from cloudX-{env}-{user}
+                    self.print_status(f"AWS profile '{self.profile}' exists and matches cloudX format", True, 2)
+                    return True
+                else:
+                    self.print_status(f"AWS profile exists but doesn't match cloudX-{{env}}-{{user}} format", False, 2)
+                    self.print_status("Please ensure your IAM user follows the format: cloudX-{env}-{username}", None, 2)
+                    return False
+            except ClientError:
+                self.print_status("Invalid AWS credentials", False, 2)
+                return False
+
+        except Exception as e:
+            self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 2)
+            return False
+
+    def setup_ssh_key(self) -> bool:
+        """Set up SSH key pair.
+        
+        Returns:
+            bool: True if key was set up successfully
+        """
+        self.print_header("SSH Key Configuration")
+        self.print_status(f"Checking SSH key '{self.ssh_key}' configuration...")
+        
+        try:
+            # Create .ssh/vscode directory if it doesn't exist
+            self.ssh_dir.mkdir(parents=True, exist_ok=True)
+            self.print_status("SSH directory exists", True, 2)
+            
+            key_exists = self.ssh_key_file.exists() and (self.ssh_key_file.with_suffix('.pub')).exists()
+            
+            if key_exists:
+                self.print_status(f"SSH key '{self.ssh_key}' exists", True, 2)
+                self.using_1password = self.prompt("Would you like to use 1Password SSH agent?", "N").lower() == 'y'
+                if self.using_1password:
+                    self.print_status("Using 1Password SSH agent", True, 2)
+                else:
+                    store_in_1password = self.prompt("Would you like to store the private key in 1Password?", "N").lower() == 'y'
+                    if store_in_1password:
+                        if self._store_key_in_1password():
+                            self.print_status("Private key stored in 1Password", True, 2)
+                        else:
+                            self.print_status("Failed to store private key in 1Password", False, 2)
+            else:
+                self.print_status(f"Generating new SSH key '{self.ssh_key}'...", None, 2)
+                subprocess.run([
+                    'ssh-keygen',
+                    '-t', 'ed25519',
+                    '-f', str(self.ssh_key_file),
+                    '-N', ''  # Empty passphrase
+                ], check=True)
+                self.print_status("SSH key generated", True, 2)
+                
+                self.using_1password = self.prompt("Would you like to use 1Password SSH agent?", "N").lower() == 'y'
+                if self.using_1password:
+                    self.print_status("Using 1Password SSH agent", True, 2)
+                else:
+                    store_in_1password = self.prompt("Would you like to store the private key in 1Password?", "N").lower() == 'y'
+                    if store_in_1password:
+                        if self._store_key_in_1password():
+                            self.print_status("Private key stored in 1Password", True, 2)
+                        else:
+                            self.print_status("Failed to store private key in 1Password", False, 2)
+            
+            return True
+
+        except Exception as e:
+            self.print_status(f"Error: {str(e)}", False, 2)
+            continue_setup = self.prompt("Would you like to continue anyway?", "Y").lower() != 'n'
+            if continue_setup:
+                self.print_status("Continuing setup despite SSH key issues", None, 2)
+                return True
+            return False
+
+    def _store_key_in_1password(self) -> bool:
+        """Store SSH private key in 1Password.
+        
+        Returns:
+            bool: True if key was stored successfully
+        """
+        try:
+            subprocess.run(['op', '--version'], check=True, capture_output=True)
+            print("Storing private key in 1Password...")
+            subprocess.run([
+                'op', 'document', 'create',
+                str(self.ssh_key_file),
+                '--title', f'cloudx-proxy SSH Key - {self.ssh_key}'
+            ], check=True)
+            return True
+        except subprocess.CalledProcessError:
+            print("Error: 1Password CLI not installed or not signed in.")
+            return False
+
+    def _add_host_entry(self, cloudx_env: str, instance_id: str, hostname: str, current_config: str) -> bool:
+        """Add settings to a specific host entry.
+        
+        Args:
+            cloudx_env: CloudX environment
+            instance_id: EC2 instance ID
+            hostname: Hostname for the instance
+            current_config: Current SSH config content
+        
+        Returns:
+            bool: True if settings were added successfully
+        """
+        try:
+            # Build host entry with all settings
+            proxy_command = "uvx cloudx-proxy connect %h %p"
+            if self.profile != "vscode":
+                proxy_command += f" --profile {self.profile}"
+            if self.aws_env:
+                proxy_command += f" --aws-env {self.aws_env}"
+            if self.ssh_key != "vscode":
+                proxy_command += f" --ssh-key {self.ssh_key}"
+
+            host_entry = f"""
+Host cloudx-{cloudx_env}-{hostname}
+    HostName {instance_id}
+    User ec2-user
+"""
+            if self.using_1password:
+                host_entry += f"""    IdentityAgent ~/.1password/agent.sock
+    IdentityFile {self.ssh_key_file}.pub
+    IdentitiesOnly yes
+"""
+            else:
+                host_entry += f"""    IdentityFile {self.ssh_key_file}
+"""
+            host_entry += f"""    ProxyCommand {proxy_command}
+"""
+            
+            # Append host entry
+            with open(self.ssh_config_file, 'a') as f:
+                f.write(host_entry)
+            self.print_status("Host entry added with settings", True, 2)
+            return True
+
+        except Exception as e:
+            self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 2)
+            continue_setup = self.prompt("Would you like to continue anyway?", "Y").lower() != 'n'
+            if continue_setup:
+                self.print_status("Continuing setup despite SSH config issues", None, 2)
+                return True
+            return False
+
+    def setup_ssh_config(self, cloudx_env: str, instance_id: str, hostname: str) -> bool:
+        """Set up SSH config for the instance.
+        
+        This method manages the SSH configuration in ~/.ssh/vscode/config, with the following behavior:
+        1. For a new environment (if cloudx-{env}-* doesn't exist):
+           Creates a base config with:
+           - User and key configuration
+           - 1Password SSH agent integration if selected
+           - ProxyCommand using uvx cloudx-proxy with proper parameters
+        
+        2. For an existing environment:
+           - Skips creating duplicate environment config
+           - Only adds the new host entry
+        
+        Example config structure:
+        ```
+        # Base environment config (created only once per environment)
+        Host cloudx-{env}-*
+            User ec2-user
+            IdentityAgent ~/.1password/agent.sock  # If using 1Password
+            IdentityFile ~/.ssh/vscode/key.pub    # .pub for 1Password, no .pub otherwise
+            IdentitiesOnly yes                    # If using 1Password
+            ProxyCommand uvx cloudx-proxy connect %h %p --profile profile --aws-env env
+        
+        # Host entries (added for each instance)
+        Host cloudx-{env}-hostname
+            HostName i-1234567890
+        ```
+        
+        Args:
+            cloudx_env: CloudX environment (e.g., dev, prod)
+            instance_id: EC2 instance ID
+            hostname: Hostname for the instance
+        
+        Returns:
+            bool: True if config was set up successfully
+        """
+        self.print_header("SSH Configuration")
+        self.print_status("Setting up SSH configuration...")
+        
+        try:
+            # Check existing configuration
+            if self.ssh_config_file.exists():
+                current_config = self.ssh_config_file.read_text()
+                # Check if configuration for this environment already exists
+                if f"Host cloudx-{cloudx_env}-*" in current_config:
+                    self.print_status(f"Found existing config for cloudx-{cloudx_env}-*", True, 2)
+                    choice = self.prompt(
+                        "Would you like to (1) override the existing config or "
+                        "(2) add settings to the specific host entry?",
+                        "1"
+                    )
+                    if choice == "2":
+                        # Add settings to specific host entry
+                        self.print_status("Adding settings to specific host entry", None, 2)
+                        return self._add_host_entry(cloudx_env, instance_id, hostname, current_config)
+                    else:
+                        # Remove existing config for this environment
+                        self.print_status("Removing existing configuration", None, 2)
+                        lines = current_config.splitlines()
+                        new_lines = []
+                        skip = False
+                        for line in lines:
+                            if line.strip() == f"Host cloudx-{cloudx_env}-*":
+                                skip = True
+                            elif skip and line.startswith("Host "):
+                                skip = False
+                            if not skip:
+                                new_lines.append(line)
+                        current_config = "\n".join(new_lines)
+                        with open(self.ssh_config_file, 'w') as f:
+                            f.write(current_config)
+
+            # Create base config
+            self.print_status(f"Creating new config for cloudx-{cloudx_env}-*", None, 2)
+            # Build ProxyCommand with only non-default parameters
+            proxy_command = "uvx cloudx-proxy connect %h %p"
+            if self.profile != "vscode":
+                proxy_command += f" --profile {self.profile}"
+            if self.aws_env:
+                proxy_command += f" --aws-env {self.aws_env}"
+            if self.ssh_key != "vscode":
+                proxy_command += f" --ssh-key {self.ssh_key}"
+
+            # Build base configuration
+            base_config = f"""# cloudx-proxy SSH Configuration
+Host cloudx-{cloudx_env}-*
+    User ec2-user
+"""
+            # Add 1Password or standard key configuration
+            if self.using_1password:
+                base_config += f"""    IdentityAgent ~/.1password/agent.sock
+    IdentityFile {self.ssh_key_file}.pub
+    IdentitiesOnly yes
+"""
+            else:
+                base_config += f"""    IdentityFile {self.ssh_key_file}
+"""
+            # Add ProxyCommand
+            base_config += f"""    ProxyCommand {proxy_command}
+"""
+            
+            # If file exists, append the new config, otherwise create it
+            if self.ssh_config_file.exists():
+                with open(self.ssh_config_file, 'a') as f:
+                    f.write("\n" + base_config)
+            else:
+                self.ssh_config_file.write_text(base_config)
+            self.print_status("Base configuration created", True, 2)
+
+            # Add specific host entry
+            self.print_status(f"Adding host entry for cloudx-{cloudx_env}-{hostname}", None, 2)
+            host_entry = f"""
+Host cloudx-{cloudx_env}-{hostname}
+    HostName {instance_id}
+"""
+            with open(self.ssh_config_file, 'a') as f:
+                f.write(host_entry)
+            self.print_status("Host entry added", True, 2)
+
+            # Ensure main SSH config includes our config
+            main_config = Path(self.home_dir) / ".ssh" / "config"
+            include_line = f"Include {self.ssh_config_file}\n"
+            
+            if main_config.exists():
+                content = main_config.read_text()
+                if include_line not in content:
+                    with open(main_config, 'a') as f:
+                        f.write(f"\n{include_line}")
+                    self.print_status("Added include line to main SSH config", True, 2)
+                else:
+                    self.print_status("Main SSH config already includes our config", True, 2)
+            else:
+                main_config.write_text(include_line)
+                self.print_status("Created main SSH config with include line", True, 2)
+
+            self.print_status("\nSSH configuration summary:", None)
+            self.print_status(f"Main config: {main_config}", None, 2)
+            self.print_status(f"cloudx-proxy config: {self.ssh_config_file}", None, 2)
+            self.print_status(f"Connect using: ssh cloudx-{cloudx_env}-{hostname}", None, 2)
+            
+            return True
+
+        except Exception as e:
+            self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 2)
+            continue_setup = self.prompt("Would you like to continue anyway?", "Y").lower() != 'n'
+            if continue_setup:
+                self.print_status("Continuing setup despite SSH config issues", None, 2)
+                return True
+            return False
+
+    def check_instance_setup(self, instance_id: str) -> Tuple[bool, bool]:
+        """Check if instance setup is complete.
+        
+        Args:
+            instance_id: EC2 instance ID
+        
+        Returns:
+            Tuple[bool, bool]: (is_running, is_setup_complete)
+        """
+        try:
+            session = boto3.Session(profile_name=self.profile)
+            ssm = session.client('ssm')
+            
+            # Check if instance is online in SSM
+            self.print_status("Checking instance status in SSM...", None, 4)
+            response = ssm.describe_instance_information(
+                Filters=[{'Key': 'InstanceIds', 'Values': [instance_id]}]
+            )
+            is_running = bool(response['InstanceInformationList'])
+            
+            if not is_running:
+                self.print_status("Instance is not accessible via SSM", False, 4)
+                return False, False
+            
+            self.print_status("Instance is accessible via SSM", True, 4)
+            
+            # Check setup status using SSM command
+            self.print_status("Checking setup status...", None, 4)
+            response = ssm.send_command(
+                InstanceIds=[instance_id],
+                DocumentName='AWS-RunShellScript',
+                Parameters={
+                    'commands': [
+                        'test -f /home/ec2-user/.install-done && echo "DONE" || '
+                        'test -f /home/ec2-user/.install-running && echo "RUNNING" || '
+                        'echo "NOT_STARTED"'
+                    ]
+                }
+            )
+            
+            command_id = response['Command']['CommandId']
+            
+            # Wait for command completion
+            for _ in range(10):  # 10 second timeout
+                time.sleep(1)
+                result = ssm.get_command_invocation(
+                    CommandId=command_id,
+                    InstanceId=instance_id
+                )
+                if result['Status'] in ['Success', 'Failed']:
+                    break
+            
+            is_setup_complete = result['Status'] == 'Success' and result['StandardOutputContent'].strip() == 'DONE'
+            
+            if is_setup_complete:
+                self.print_status("Setup is complete", True, 4)
+            else:
+                status = result['StandardOutputContent'].strip()
+                self.print_status(f"Setup status: {status}", None, 4)
+            
+            return True, is_setup_complete
+
+        except Exception as e:
+            self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 4)
+            return False, False
+
+    def wait_for_setup_completion(self, instance_id: str) -> bool:
+        """Wait for instance setup to complete.
+        
+        Args:
+            instance_id: EC2 instance ID
+        
+        Returns:
+            bool: True if setup completed successfully
+        """
+        self.print_header("Instance Setup Check")
+        self.print_status(f"Checking instance {instance_id} setup status...")
+        
+        is_running, is_complete = self.check_instance_setup(instance_id)
+        
+        if not is_running:
+            self.print_status("Instance is not running or not accessible via SSM", False, 2)
+            continue_setup = self.prompt("Would you like to continue anyway?", "Y").lower() != 'n'
+            if continue_setup:
+                self.print_status("Continuing setup despite instance access issues", None, 2)
+                return True
+            return False
+        
+        if is_complete:
+            self.print_status("Instance setup is complete", True, 2)
+            return True
+        
+        wait = self.prompt("Instance setup is not complete. Would you like to wait?", "Y").lower() != 'n'
+        if not wait:
+            self.print_status("Skipping instance setup check", None, 2)
+            return True
+        
+        self.print_status("Waiting for setup to complete...", None, 2)
+        dots = 0
+        while True:
+            is_running, is_complete = self.check_instance_setup(instance_id)
+            
+            if not is_running:
+                self.print_status("Instance is no longer running or accessible", False, 2)
+                continue_setup = self.prompt("Would you like to continue anyway?", "Y").lower() != 'n'
+                if continue_setup:
+                    self.print_status("Continuing setup despite instance issues", None, 2)
+                    return True
+                return False
+            
+            if is_complete:
+                self.print_status("Instance setup completed successfully", True, 2)
+                return True
+            
+            dots = (dots + 1) % 4
+            print(f"\r  {'.' * dots}{' ' * (3 - dots)}", end='', flush=True)
+            time.sleep(10)

{cloudx_proxy-0.1.1 → cloudx_proxy-0.3.0}/cloudx_proxy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cloudx-proxy
-Version: 0.1.1
+Version: 0.3.0
 Summary: SSH proxy command to connect VSCode with Cloud9/CloudX instance using AWS Systems Manager
 Author-email: easytocloud <info@easytocloud.com>
 License: MIT License

cloudx_proxy-0.1.1/CHANGELOG.md

@@ -1,21 +0,0 @@
-## [0.1.1](https://github.com/easytocloud/cloudX-proxy/compare/v0.1.0...v0.1.1) (2025-02-09)
-
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-## [0.1.0](https://github.com/easytocloud/cloudX-proxy/releases/tag/v0.1.0) (2025-02-09)
-
-Initial release with core functionality:
-
-### Features
-
-* SSH proxy command for connecting VSCode to EC2 instances via SSM
-* AWS profile configuration with cloudX-{env}-{user} format
-* SSH key management with 1Password integration
-* Environment-specific SSH config generation
-* Instance setup status verification
-* Cross-platform support (Windows, macOS, Linux)
-* Automatic instance startup if stopped
-* SSH key distribution via EC2 Instance Connect
-* SSH tunneling through AWS Systems Manager

cloudx_proxy-0.1.1/cloudx_proxy/setup.py

@@ -1,336 +0,0 @@
-import os
-import time
-import json
-import subprocess
-from pathlib import Path
-from typing import Optional, Tuple
-import boto3
-from botocore.exceptions import ClientError
-
-class CloudXSetup:
-    def __init__(self, profile: str = "vscode", ssh_key: str = "vscode", aws_env: str = None):
-        """Initialize CloudX setup.
-        
-        Args:
-            profile: AWS profile name (default: "vscode")
-            ssh_key: SSH key name (default: "vscode")
-            aws_env: AWS environment directory (default: None)
-        """
-        self.profile = profile
-        self.ssh_key = ssh_key
-        self.aws_env = aws_env
-        self.home_dir = str(Path.home())
-        self.ssh_dir = Path(self.home_dir) / ".ssh" / "vscode"
-        self.ssh_config_file = self.ssh_dir / "config"
-        self.ssh_key_file = self.ssh_dir / f"{ssh_key}"
-        self.using_1password = False
-
-    def setup_aws_profile(self) -> bool:
-        """Set up AWS profile using aws configure command.
-        
-        Returns:
-            bool: True if profile was set up successfully
-        """
-        try:
-            # Configure AWS environment if specified
-            if self.aws_env:
-                aws_env_dir = os.path.expanduser(f"~/.aws/aws-envs/{self.aws_env}")
-                os.environ["AWS_CONFIG_FILE"] = os.path.join(aws_env_dir, "config")
-                os.environ["AWS_SHARED_CREDENTIALS_FILE"] = os.path.join(aws_env_dir, "credentials")
-
-            # Check if profile exists
-            session = boto3.Session(profile_name=self.profile)
-            try:
-                session.client('sts').get_caller_identity()
-                print(f"AWS profile '{self.profile}' already exists and is valid.")
-                return True
-            except ClientError:
-                pass
-
-            # Profile doesn't exist or is invalid, set it up
-            print(f"Setting up AWS profile '{self.profile}'...")
-            print("Please enter your AWS credentials:")
-            
-            # Use aws configure command
-            subprocess.run([
-                'aws', 'configure',
-                '--profile', self.profile
-            ], check=True)
-
-            # Verify the profile works
-            session = boto3.Session(profile_name=self.profile)
-            identity = session.client('sts').get_caller_identity()
-            user_arn = identity['Arn']
-            
-            if not any(part.startswith('cloudX-') for part in user_arn.split('/')):
-                print(f"Warning: User ARN '{user_arn}' does not match expected format cloudX-{{env}}-{{user}}")
-            
-            return True
-
-        except Exception as e:
-            print(f"Error setting up AWS profile: {e}")
-            return False
-
-    def setup_ssh_key(self) -> bool:
-        """Set up SSH key pair.
-        
-        Returns:
-            bool: True if key was set up successfully
-        """
-        try:
-            # Create .ssh/vscode directory if it doesn't exist
-            self.ssh_dir.mkdir(parents=True, exist_ok=True)
-            
-            key_exists = self.ssh_key_file.exists() and (self.ssh_key_file.with_suffix('.pub')).exists()
-            
-            if key_exists:
-                print(f"SSH key '{self.ssh_key}' already exists.")
-                self.using_1password = input("Would you like to use 1Password SSH agent? (y/N): ").lower() == 'y'
-                if not self.using_1password:
-                    store_in_1password = input("Would you like to store the private key in 1Password? (y/N): ").lower() == 'y'
-                    if store_in_1password:
-                        self._store_key_in_1password()
-            else:
-                print(f"Generating new SSH key '{self.ssh_key}'...")
-                subprocess.run([
-                    'ssh-keygen',
-                    '-t', 'ed25519',
-                    '-f', str(self.ssh_key_file),
-                    '-N', ''  # Empty passphrase
-                ], check=True)
-                
-                self.using_1password = input("Would you like to use 1Password SSH agent? (y/N): ").lower() == 'y'
-                if not self.using_1password:
-                    store_in_1password = input("Would you like to store the private key in 1Password? (y/N): ").lower() == 'y'
-                    if store_in_1password:
-                        self._store_key_in_1password()
-            
-            return True
-
-        except Exception as e:
-            print(f"Error setting up SSH key: {e}")
-            return False
-
-    def _store_key_in_1password(self) -> bool:
-        """Store SSH private key in 1Password.
-        
-        Returns:
-            bool: True if key was stored successfully
-        """
-        try:
-            subprocess.run(['op', '--version'], check=True, capture_output=True)
-            print("Storing private key in 1Password...")
-            subprocess.run([
-                'op', 'document', 'create',
-                str(self.ssh_key_file),
-                '--title', f'CloudX SSH Key - {self.ssh_key}'
-            ], check=True)
-            return True
-        except subprocess.CalledProcessError:
-            print("Error: 1Password CLI not installed or not signed in.")
-            return False
-
-    def setup_ssh_config(self, cloudx_env: str, instance_id: str, hostname: str) -> bool:
-        """Set up SSH config for the instance.
-        
-        This method manages the SSH configuration in ~/.ssh/vscode/config, with the following behavior:
-        1. For a new environment (if cloudx-{env}-* doesn't exist):
-           Creates a base config with:
-           - User and key configuration
-           - 1Password SSH agent integration if selected
-           - ProxyCommand using uvx cloudx-proxy with proper parameters
-        
-        2. For an existing environment:
-           - Skips creating duplicate environment config
-           - Only adds the new host entry
-        
-        Example config structure:
-        ```
-        # Base environment config (created only once per environment)
-        Host cloudx-{env}-*
-            User ec2-user
-            IdentityAgent ~/.1password/agent.sock  # If using 1Password
-            IdentityFile ~/.ssh/vscode/key.pub    # .pub for 1Password, no .pub otherwise
-            IdentitiesOnly yes                    # If using 1Password
-            ProxyCommand uvx cloudx-proxy connect %h %p --profile profile --aws-env env
-        
-        # Host entries (added for each instance)
-        Host cloudx-{env}-hostname
-            HostName i-1234567890
-        ```
-        
-        Args:
-            cloudx_env: CloudX environment (e.g., dev, prod)
-            instance_id: EC2 instance ID
-            hostname: Hostname for the instance
-        
-        Returns:
-            bool: True if config was set up successfully
-        """
-        try:
-            # Check if we need to create base config
-            need_base_config = True
-            if self.ssh_config_file.exists():
-                current_config = self.ssh_config_file.read_text()
-                # Check if configuration for this environment already exists
-                if f"Host cloudx-{cloudx_env}-*" in current_config:
-                    need_base_config = False
-            
-            if need_base_config:
-                # Build ProxyCommand with all necessary parameters
-                proxy_command = f"uvx cloudx-proxy connect %h %p --profile {self.profile}"
-                if self.aws_env:
-                    proxy_command += f" --aws-env {self.aws_env}"
-                if self.ssh_key != "vscode":
-                    proxy_command += f" --key-path {self.ssh_key_file}.pub"
-
-                # Build base configuration
-                base_config = f"""# CloudX SSH Configuration
-Host cloudx-{cloudx_env}-*
-    User ec2-user
-"""
-                # Add 1Password or standard key configuration
-                if self.using_1password:
-                    base_config += f"""    IdentityAgent ~/.1password/agent.sock
-    IdentityFile {self.ssh_key_file}.pub
-    IdentitiesOnly yes
-"""
-                else:
-                    base_config += f"""    IdentityFile {self.ssh_key_file}
-"""
-                # Add ProxyCommand
-                base_config += f"""    ProxyCommand {proxy_command}
-"""
-                
-                # If file exists, append the new config, otherwise create it
-                if self.ssh_config_file.exists():
-                    with open(self.ssh_config_file, 'a') as f:
-                        f.write("\n" + base_config)
-                else:
-                    self.ssh_config_file.write_text(base_config)
-
-            # Add specific host entry
-            host_entry = f"""
-Host cloudx-{cloudx_env}-{hostname}
-    HostName {instance_id}
-"""
-            with open(self.ssh_config_file, 'a') as f:
-                f.write(host_entry)
-
-            # Ensure main SSH config includes our config
-            main_config = Path(self.home_dir) / ".ssh" / "config"
-            include_line = f"Include {self.ssh_config_file}\n"
-            
-            if main_config.exists():
-                content = main_config.read_text()
-                if include_line not in content:
-                    with open(main_config, 'a') as f:
-                        f.write(f"\n{include_line}")
-            else:
-                main_config.write_text(include_line)
-
-            print(f"\nSSH configuration has been set up:")
-            print(f"- Main config file: {main_config}")
-            print(f"- CloudX config file: {self.ssh_config_file}")
-            print(f"\nYou can now connect using: ssh cloudx-{cloudx_env}-{hostname}")
-            
-            return True
-
-        except Exception as e:
-            print(f"Error setting up SSH config: {e}")
-            return False
-
-    def check_instance_setup(self, instance_id: str) -> Tuple[bool, bool]:
-        """Check if instance setup is complete.
-        
-        Args:
-            instance_id: EC2 instance ID
-        
-        Returns:
-            Tuple[bool, bool]: (is_running, is_setup_complete)
-        """
-        try:
-            session = boto3.Session(profile_name=self.profile)
-            ssm = session.client('ssm')
-            
-            # Check if instance is online in SSM
-            response = ssm.describe_instance_information(
-                Filters=[{'Key': 'InstanceIds', 'Values': [instance_id]}]
-            )
-            is_running = bool(response['InstanceInformationList'])
-            
-            if not is_running:
-                return False, False
-            
-            # Check setup status using SSM command
-            response = ssm.send_command(
-                InstanceIds=[instance_id],
-                DocumentName='AWS-RunShellScript',
-                Parameters={
-                    'commands': [
-                        'test -f /home/ec2-user/.install-done && echo "DONE" || '
-                        'test -f /home/ec2-user/.install-running && echo "RUNNING" || '
-                        'echo "NOT_STARTED"'
-                    ]
-                }
-            )
-            
-            command_id = response['Command']['CommandId']
-            
-            # Wait for command completion
-            for _ in range(10):  # 10 second timeout
-                time.sleep(1)
-                result = ssm.get_command_invocation(
-                    CommandId=command_id,
-                    InstanceId=instance_id
-                )
-                if result['Status'] in ['Success', 'Failed']:
-                    break
-            
-            is_setup_complete = result['Status'] == 'Success' and result['StandardOutputContent'].strip() == 'DONE'
-            
-            return True, is_setup_complete
-
-        except Exception as e:
-            print(f"Error checking instance setup: {e}")
-            return False, False
-
-    def wait_for_setup_completion(self, instance_id: str) -> bool:
-        """Wait for instance setup to complete.
-        
-        Args:
-            instance_id: EC2 instance ID
-        
-        Returns:
-            bool: True if setup completed successfully
-        """
-        print(f"Checking setup status for instance {instance_id}...")
-        
-        is_running, is_complete = self.check_instance_setup(instance_id)
-        
-        if not is_running:
-            print("Error: Instance is not running or not accessible via SSM")
-            return False
-        
-        if is_complete:
-            print("Instance setup is already complete")
-            return True
-        
-        wait = input("Instance setup is not complete. Would you like to wait? (Y/n): ").lower() != 'n'
-        if not wait:
-            return False
-        
-        print("Waiting for setup to complete", end='', flush=True)
-        while True:
-            is_running, is_complete = self.check_instance_setup(instance_id)
-            
-            if not is_running:
-                print("\nError: Instance is no longer running or accessible")
-                return False
-            
-            if is_complete:
-                print("\nInstance setup completed successfully")
-                return True
-            
-            print(".", end='', flush=True)
-            time.sleep(10)