cloudx-proxy 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/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/setup.py

@@ -9,7 +9,7 @@ from botocore.exceptions import ClientError
 
 class CloudXSetup:
     def __init__(self, profile: str = "vscode", ssh_key: str = "vscode", aws_env: str = None):
-        """Initialize CloudX setup.
+        """Initialize cloudx-proxy setup.
         
         Args:
             profile: AWS profile name (default: "vscode")
@@ -24,13 +24,58 @@ class CloudXSetup:
         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
+            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:
@@ -38,37 +83,45 @@ class CloudXSetup:
                 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 to create session with 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)
+                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
-            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
+            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:
-            print(f"Error setting up AWS profile: {e}")
+            self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 2)
             return False
 
     def setup_ssh_key(self) -> bool:
@@ -77,38 +130,57 @@ class CloudXSetup:
         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:
-                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'
+                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:
-                        self._store_key_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:
-                print(f"Generating new SSH key '{self.ssh_key}'...")
+                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 = 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'
+                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:
-                        self._store_key_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:
-            print(f"Error setting up SSH key: {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:
@@ -123,13 +195,65 @@ class CloudXSetup:
             subprocess.run([
                 'op', 'document', 'create',
                 str(self.ssh_key_file),
-                '--title', f'CloudX SSH Key - {self.ssh_key}'
+                '--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.
         
@@ -167,55 +291,88 @@ class CloudXSetup:
         Returns:
             bool: True if config was set up successfully
         """
+        self.print_header("SSH Configuration")
+        self.print_status("Setting up SSH configuration...")
+        
         try:
-            # Check if we need to create base config
-            need_base_config = True
+            # 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:
-                    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"
+                    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 SSH Configuration
+            # 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
+            # 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}
+            else:
+                base_config += f"""    IdentityFile {self.ssh_key_file}
 """
-                # Add ProxyCommand
-                base_config += f"""    ProxyCommand {proxy_command}
+            # 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)
+            
+            # 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"
@@ -226,18 +383,26 @@ Host cloudx-{cloudx_env}-{hostname}
                 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)
 
-            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}")
+            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:
-            print(f"Error setting up SSH config: {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]:
@@ -254,15 +419,20 @@ Host cloudx-{cloudx_env}-{hostname}
             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',
@@ -289,10 +459,16 @@ Host cloudx-{cloudx_env}-{hostname}
             
             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:
-            print(f"Error checking instance setup: {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:
@@ -304,33 +480,45 @@ Host cloudx-{cloudx_env}-{hostname}
         Returns:
             bool: True if setup completed successfully
         """
-        print(f"Checking setup status for instance {instance_id}...")
+        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:
-            print("Error: Instance is not running or not accessible via SSM")
+            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:
-            print("Instance setup is already complete")
+            self.print_status("Instance setup is complete", True, 2)
             return True
         
-        wait = input("Instance setup is not complete. Would you like to wait? (Y/n): ").lower() != 'n'
+        wait = self.prompt("Instance setup is not complete. Would you like to wait?", "Y").lower() != 'n'
         if not wait:
-            return False
+            self.print_status("Skipping instance setup check", None, 2)
+            return True
         
-        print("Waiting for setup to complete", end='', flush=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:
-                print("\nError: Instance is no longer running or accessible")
+                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:
-                print("\nInstance setup completed successfully")
+                self.print_status("Instance setup completed successfully", True, 2)
                 return True
             
-            print(".", end='', flush=True)
+            dots = (dots + 1) % 4
+            print(f"\r  {'.' * dots}{' ' * (3 - dots)}", end='', flush=True)
             time.sleep(10)

{cloudx_proxy-0.1.1.dist-info → cloudx_proxy-0.3.0.dist-info}/METADATA

@@ -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.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cloudx_proxy/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
+cloudx_proxy/_version.py,sha256=Jk2iAU7m-7Vx9XV1TtdD9ZoJraIncDq_4_Wd-qtUotg,411
+cloudx_proxy/cli.py,sha256=Ph-m8lDsdU2zZab9Y6YgBBzd_UDouBnfNrYFFx0bI_E,3426
+cloudx_proxy/core.py,sha256=j6CUKdg2Ikcoi-05ceXMGA_c1aGWBhN9_JevbkLkaUY,7383
+cloudx_proxy/setup.py,sha256=Y8YYMJ47fb57FAr6llQaFGuVOQ-fstYEg_Pdv5uCd-A,22486
+cloudx_proxy-0.3.0.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
+cloudx_proxy-0.3.0.dist-info/METADATA,sha256=A2WZ_EGsVVB-DadxbUYDy1oeUVaSoArx3IuePpdv0DQ,10216
+cloudx_proxy-0.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+cloudx_proxy-0.3.0.dist-info/entry_points.txt,sha256=HGt743N2lVlKd7O1qWq3C0aEHyS5PjPnxzDHh7hwtSg,54
+cloudx_proxy-0.3.0.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
+cloudx_proxy-0.3.0.dist-info/RECORD,,

cloudx_proxy-0.1.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-cloudx_proxy/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
-cloudx_proxy/_version.py,sha256=PKIMyjdUACH4-ONvtunQCnYE2UhlMfp9su83e3HXl5E,411
-cloudx_proxy/cli.py,sha256=zqOIynqNr76JE6VRF7ifn3Fr0Z5C6CjnAHQgupF30BU,3374
-cloudx_proxy/core.py,sha256=j6CUKdg2Ikcoi-05ceXMGA_c1aGWBhN9_JevbkLkaUY,7383
-cloudx_proxy/setup.py,sha256=5GGfPgIiEWwkFEY-HnnPvT_8iD94WqjoFjJ5tGSHz8o,13157
-cloudx_proxy-0.1.1.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
-cloudx_proxy-0.1.1.dist-info/METADATA,sha256=tBwYeyqWuPOsREgWQylDRn6je6FZ1REbBQu5Pgk6I1s,10216
-cloudx_proxy-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-cloudx_proxy-0.1.1.dist-info/entry_points.txt,sha256=HGt743N2lVlKd7O1qWq3C0aEHyS5PjPnxzDHh7hwtSg,54
-cloudx_proxy-0.1.1.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
-cloudx_proxy-0.1.1.dist-info/RECORD,,