cloudx-proxy 2025.3.0__py3-none-any.whl → 2026.0.2__py3-none-any.whl

cloudx_proxy/__init__.py

@@ -1,6 +1,3 @@
-"""CloudX Client - Connect to EC2 instances via SSM for VSCode Remote SSH."""
-
-from .core import CloudXClient
 from ._version import __version__
 
-__all__ = ["CloudXClient", "__version__"]
+__all__ = ['__version__']

cloudx_proxy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2025.3.0'
-__version_tuple__ = version_tuple = (2025, 3, 0)
+__version__ = version = '2026.0.2'
+__version_tuple__ = version_tuple = (2026, 0, 2)

cloudx_proxy/cli.py

@@ -1,24 +1,32 @@
 import os
 import sys
 import click
+from . import __version__
 from .core import CloudXClient
+from .setup import CloudXSetup
 
-@click.command()
+@click.group()
+@click.version_option(version=__version__)
+def cli():
+    """CloudX Client - Connect to EC2 instances via SSM for VSCode Remote SSH."""
+    pass
+
+@cli.command()
 @click.argument('instance_id')
 @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('--aws-env', help='AWS environment directory (default: ~/.aws, use name of directory in ~/.aws/aws-envs/)')
-def main(instance_id: str, port: int, profile: str, region: str, key_path: str, aws_env: str):
-    """CloudX Client - Connect to EC2 instances via SSM for VSCode Remote SSH.
+def connect(instance_id: str, port: int, profile: str, region: str, key_path: 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)
     
     Example usage:
-        uvx cloudx-client i-0123456789abcdef0 22
-        uvx cloudx-client i-0123456789abcdef0 22 --profile myprofile --region eu-west-1
-        uvx cloudx-client i-0123456789abcdef0 22 --aws-env prod
+        cloudx-proxy i-0123456789abcdef0 22
+        cloudx-proxy i-0123456789abcdef0 22 --profile myprofile --region eu-west-1
+        cloudx-proxy i-0123456789abcdef0 22 --aws-env prod
     """
     try:
         client = CloudXClient(
@@ -37,5 +45,49 @@ def main(instance_id: str, port: int, profile: str, region: str, key_path: str,
         print(f"Error: {str(e)}", file=sys.stderr)
         sys.exit(1)
 
+@cli.command()
+@click.option('--profile', default='vscode', help='AWS profile to use (default: vscode)')
+@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 setup(profile: str, ssh_key: str, aws_env: str):
+    """Set up AWS profile, SSH keys, and configuration for CloudX.
+    
+    This command will:
+    1. Set up AWS profile with credentials
+    2. Create or use existing SSH key
+    3. Configure SSH for CloudX instances
+    4. Check instance setup status
+    
+    Example usage:
+        cloudx-proxy setup
+        cloudx-proxy setup --profile myprofile --ssh-key mykey
+    """
+    try:
+        setup = CloudXSetup(profile=profile, ssh_key=ssh_key, aws_env=aws_env)
+        
+        # Set up AWS profile
+        if not setup.setup_aws_profile():
+            sys.exit(1)
+        
+        # Set up SSH key
+        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)
+        
+        # Set up SSH config
+        if not setup.setup_ssh_config(cloudx_env, instance_id, hostname):
+            sys.exit(1)
+        
+        # Check instance setup status
+        setup.wait_for_setup_completion(instance_id)
+        
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
 if __name__ == '__main__':
-    main()
+    cli()

cloudx_proxy/setup.py

@@ -0,0 +1,336 @@
+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)

{cloudx_proxy-2025.3.0.dist-info → cloudx_proxy-2026.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cloudx-proxy
-Version: 2025.3.0
+Version: 2026.0.2
 Summary: SSH proxy command to connect VSCode with Cloud9/CloudX instance using AWS Systems Manager
 Author-email: easytocloud <info@easytocloud.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
         
 Project-URL: Homepage, https://github.com/easytocloud/cloudX-proxy
-Project-URL: Repository, https://github.com/easytocloud/cloudX-proxy.git
+Project-URL: Repository, https://github.com/easytocloud/cloudX-proxy
 Project-URL: Issues, https://github.com/easytocloud/cloudX-proxy/issues
 Project-URL: Changelog, https://github.com/easytocloud/cloudX-proxy/blob/main/CHANGELOG.md
 Keywords: aws,vscode,cloud9,cloudX,ssm,ssh,proxy
@@ -93,81 +93,64 @@ The proxy also supports easytocloud's AWS profile organizer. If you use multiple
 
 ## Setup
 
-1. Deploy the cloudX-user stack in your AWS account to create the necessary IAM user
-2. Configure the 'vscode' AWS profile with the credentials from the cloudX-user stack
-3. Install uv if you haven't already:
-   ```bash
-   pip install uv
-   ```
+cloudX-proxy now includes a setup command that automates the entire configuration process:
 
-The `uvx` command, part of the uv package manager, makes running cloudX-proxy seamless. When you run `uvx cloudx-proxy`, it automatically:
-- Pulls the latest version from PyPI
-- Creates an isolated virtual environment
-- Installs all dependencies
-- Runs the code
+```bash
+# Basic setup with defaults (vscode profile and key)
+uvx cloudx-proxy setup
 
-All of this happens in a single, fast operation without any manual setup required.
+# Setup with custom profile and key
+uvx cloudx-proxy setup --profile myprofile --ssh-key mykey
 
-## SSH Configuration
+# Setup with AWS environment
+uvx cloudx-proxy setup --aws-env prod
+```
 
-### 1. Generate SSH Key Pair
+The setup command will:
 
-If you don't already have an SSH key pair for VSCode:
+1. Configure AWS Profile:
+   - Creates/validates AWS profile with cloudX-{env}-{user} format
+   - Supports AWS environment directories via --aws-env
+   - Uses aws configure for credential input
 
-```bash
-# Create .ssh/vscode directory
-mkdir -p ~/.ssh/vscode
+2. Manage SSH Keys:
+   - Creates new SSH key pair if needed
+   - Offers 1Password integration options:
+     * Using 1Password SSH agent
+     * Storing private key as 1Password document
 
-# Generate key pair
-ssh-keygen -t rsa -b 4096 -f ~/.ssh/vscode/vscode
-```
+3. Configure SSH:
+   - Creates ~/.ssh/vscode/config with proper settings
+   - Sets up environment-specific configurations
+   - Configures ProxyCommand with all necessary parameters
+   - Ensures main ~/.ssh/config includes the configuration
 
-### 2. Configure SSH
+4. Verify Instance Setup:
+   - Checks instance setup status
+   - Offers to wait for setup completion
+   - Monitors setup progress
 
-#### Unix-like Systems (macOS/Linux)
+### Example SSH Configuration
 
-1. Create or edit `~/.ssh/config`:
-   ```bash
-   # Include VSCode-specific config
-   Include vscode/config
-   ```
+The setup command generates a configuration structure like this:
 
-2. Create `~/.ssh/vscode/config`:
-   ```
-   Host cloudx-*
-       ProxyCommand uvx cloudx-proxy %h %p
-       User ec2-user
-       IdentityFile ~/.ssh/vscode/vscode
-       StrictHostKeyChecking no
-       UserKnownHostsFile /dev/null
-
-   # Example host configuration
-   Host cloudx-dev
-       HostName i-0123456789abcdef0  # Your EC2 instance ID
-   ```
-
-#### Windows
-
-1. Create or edit `%USERPROFILE%\.ssh\config`:
-   ```
-   Include vscode/config
-   ```
+```
+# Base environment config (created 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
+```
 
-2. Create `%USERPROFILE%\.ssh\vscode\config`:
-   ```
-   Host cloudx-*
-       ProxyCommand uvx cloudx-proxy %h %p
-       User ec2-user
-       IdentityFile %USERPROFILE%\.ssh\vscode\vscode
-       StrictHostKeyChecking no
-       UserKnownHostsFile /dev/null
-
-   # Example host configuration
-   Host cloudx-dev
-       HostName i-0123456789abcdef0  # Your EC2 instance ID
-   ```
+When adding new instances to an existing environment, the setup command will only add the specific host entry, preserving the existing environment configuration.
 
-### 3. VSCode Configuration
+### VSCode Configuration
 
 1. Install the "Remote - SSH" extension in VSCode
 2. Configure VSCode settings:
@@ -183,23 +166,23 @@ ssh-keygen -t rsa -b 4096 -f ~/.ssh/vscode/vscode
 ### Command Line
 
 ```bash
-# Basic usage (uses default vscode profile, port 22, and eu-west-1 region)
-uvx cloudx-proxy i-0123456789abcdef0
+# Setup new environment and instance
+uvx cloudx-proxy setup --profile myprofile --aws-env prod
 
-# With custom port
-uvx cloudx-proxy i-0123456789abcdef0 2222
+# Add instance to existing environment
+uvx cloudx-proxy setup --profile myprofile --aws-env prod
 
-# With custom profile
-uvx cloudx-proxy i-0123456789abcdef0 --profile myprofile
+# Connect to instance
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --profile myprofile --aws-env prod
 
-# With different region (overrides eu-west-1 default)
-uvx cloudx-proxy i-0123456789abcdef0 --region us-east-1
+# Connect with custom port
+uvx cloudx-proxy connect i-0123456789abcdef0 2222 --profile myprofile
 
-# With AWS profile organizer environment
-uvx cloudx-proxy i-0123456789abcdef0 --aws-env prod
+# Connect with different region
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --region us-east-1
 
-# With custom SSH key
-uvx cloudx-proxy i-0123456789abcdef0 --key-path ~/.ssh/custom_key.pub
+# Connect with custom key
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --key-path ~/.ssh/custom_key.pub
 ```
 
 ### VSCode
@@ -235,24 +218,36 @@ The AWS user/role needs these permissions:
 
 ## Troubleshooting
 
-1. **Connection Timeout**
+1. **Setup Issues**
+   - If AWS profile validation fails, ensure your user ARN matches the cloudX-{env}-{user} format
+   - For 1Password integration, ensure the CLI is installed and you're signed in
+   - Check that ~/.ssh/vscode directory has proper permissions (700)
+   - Verify main ~/.ssh/config is writable
+
+2. **Connection Timeout**
    - Ensure the instance has the SSM agent installed and running
    - Check that your AWS credentials have the required permissions
    - Verify the instance ID is correct
    - Increase the VSCode SSH timeout if needed
 
-2. **SSH Key Issues**
-   - Ensure the key pair exists in the correct location
+3. **SSH Key Issues**
+   - If using 1Password SSH agent, verify agent is running (~/.1password/agent.sock exists)
    - Check file permissions (600 for private key, 644 for public key)
    - Verify the public key is being successfully pushed to the instance
+   - For stored keys in 1Password, ensure you can access them via the CLI
 
-3. **AWS Configuration**
-   - Confirm AWS CLI is configured with valid credentials (default profile name is 'vscode')
+4. **AWS Configuration**
+   - Confirm AWS CLI is configured with valid credentials
    - Default region is eu-west-1 if not specified in profile or command line
    - If using AWS profile organizer, ensure your environment directory exists at `~/.aws/aws-envs/<environment>/`
    - Verify the Session Manager plugin is installed correctly
    - Check that the instance has the required IAM role for SSM
 
+5. **Instance Setup Status**
+   - If setup appears stuck, check /home/ec2-user/.install-running exists
+   - Verify /home/ec2-user/.install-done is created upon completion
+   - Check instance system logs for setup script errors
+
 ## License
 
 MIT License - see LICENSE file for details

cloudx_proxy-2026.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+cloudx_proxy/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
+cloudx_proxy/_version.py,sha256=5qpRRzcvqdWRxS4N-2BefN-qS2k4DLuS65JCN34TY0A,417
+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-2026.0.2.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
+cloudx_proxy-2026.0.2.dist-info/METADATA,sha256=C7ISmMQzb80SXyke-z0wZifp650UEmKC-xav1ibcI14,10219
+cloudx_proxy-2026.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+cloudx_proxy-2026.0.2.dist-info/entry_points.txt,sha256=HGt743N2lVlKd7O1qWq3C0aEHyS5PjPnxzDHh7hwtSg,54
+cloudx_proxy-2026.0.2.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
+cloudx_proxy-2026.0.2.dist-info/RECORD,,

cloudx_proxy-2026.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cloudx-proxy = cloudx_proxy.cli:cli

cloudx_proxy-2025.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-cloudx_proxy/__init__.py,sha256=YfZd1x9PT_aGA4FGsNw1WwvWkfRKLy_9O93a_W2wtiE,187
-cloudx_proxy/_version.py,sha256=fWRR5Orqc8dqtVKNeAfCqsDhc30HwoGblv4fyeGnKoY,417
-cloudx_proxy/cli.py,sha256=bBcvqiKpsLY6cYt-OG8282RZuoSDwDgEdyehTAeeec0,1502
-cloudx_proxy/core.py,sha256=j6CUKdg2Ikcoi-05ceXMGA_c1aGWBhN9_JevbkLkaUY,7383
-cloudx_proxy-2025.3.0.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
-cloudx_proxy-2025.3.0.dist-info/METADATA,sha256=I-ImXVJrHCT-tnl26xPK94FrtVwxZ-dgc7290pzp0rs,9527
-cloudx_proxy-2025.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-cloudx_proxy-2025.3.0.dist-info/entry_points.txt,sha256=BugqsX1eJtZGC6b5ONbieB9To9go2RCQVXuzdN79lZQ,55
-cloudx_proxy-2025.3.0.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
-cloudx_proxy-2025.3.0.dist-info/RECORD,,

cloudx_proxy-2025.3.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-cloudx-proxy = cloudx_proxy.cli:main