cloudx-proxy 0.1.1__py3-none-any.whl

cloudx_proxy/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ['__version__']

cloudx_proxy/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)

cloudx_proxy/cli.py

@@ -0,0 +1,93 @@
+import os
+import sys
+import click
+from . import __version__
+from .core import CloudXClient
+from .setup import CloudXSetup
+
+@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 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:
+        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(
+            instance_id=instance_id,
+            port=port,
+            profile=profile,
+            region=region,
+            public_key_path=key_path,
+            aws_env=aws_env
+        )
+        
+        if not client.connect():
+            sys.exit(1)
+            
+    except Exception as e:
+        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__':
+    cli()

cloudx_proxy/core.py

@@ -0,0 +1,189 @@
+import os
+import sys
+import time
+from pathlib import Path
+import boto3
+from botocore.exceptions import ClientError
+
+class CloudXClient:
+    def __init__(self, instance_id: str, port: int = 22, profile: str = "vscode", 
+                 region: str = None, public_key_path: str = None, aws_env: str = None):
+        """Initialize CloudX client for SSH tunneling via AWS SSM.
+        
+        Args:
+            instance_id: EC2 instance ID to connect to
+            port: SSH port number (default: 22)
+            profile: AWS profile to use (default: "vscode")
+            region: AWS region (default: from profile)
+            public_key_path: Path to SSH public key (default: ~/.ssh/vscode/vscode.pub)
+            aws_env: AWS environment directory (default: None, uses ~/.aws)
+        """
+        self.instance_id = instance_id
+        self.port = port
+        self.profile = profile
+        
+        # Configure AWS environment
+        if aws_env:
+            aws_env_dir = os.path.expanduser(f"~/.aws/aws-envs/{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")
+        
+        # Set up AWS session with eu-west-1 as default region
+        if not region:
+            # Try to get region from profile first
+            session = boto3.Session(profile_name=profile)
+            region = session.region_name or 'eu-west-1'
+        
+        self.session = boto3.Session(profile_name=profile, region_name=region)
+        self.ssm = self.session.client('ssm')
+        self.ec2 = self.session.client('ec2')
+        self.ec2_connect = self.session.client('ec2-instance-connect')
+        
+        # Default public key path if not provided
+        if not public_key_path:
+            public_key_path = os.path.expanduser("~/.ssh/vscode/vscode.pub")
+        self.public_key_path = Path(public_key_path)
+
+    def log(self, message: str) -> None:
+        """Log message to stderr to avoid interfering with SSH connection."""
+        print(message, file=sys.stderr)
+
+    def get_instance_status(self) -> str:
+        """Check if instance is online in SSM."""
+        try:
+            response = self.ssm.describe_instance_information(
+                Filters=[{'Key': 'InstanceIds', 'Values': [self.instance_id]}]
+            )
+            if response['InstanceInformationList']:
+                return response['InstanceInformationList'][0]['PingStatus']
+            return 'Offline'
+        except ClientError:
+            return 'Offline'
+
+    def start_instance(self) -> bool:
+        """Start the EC2 instance if it's stopped."""
+        try:
+            self.ec2.start_instances(InstanceIds=[self.instance_id])
+            return True
+        except ClientError as e:
+            self.log(f"Error starting instance: {e}")
+            return False
+
+    def wait_for_instance(self, max_attempts: int = 30, delay: int = 3) -> bool:
+        """Wait for instance to come online.
+        
+        Args:
+            max_attempts: Maximum number of status checks
+            delay: Seconds between checks
+        
+        Returns:
+            bool: True if instance came online, False if timeout
+        """
+        for _ in range(max_attempts):
+            if self.get_instance_status() == 'Online':
+                return True
+            time.sleep(delay)
+        return False
+
+    def push_ssh_key(self) -> bool:
+        """Push SSH public key to instance via EC2 Instance Connect."""
+        try:
+            with open(self.public_key_path) as f:
+                public_key = f.read()
+            
+            self.ec2_connect.send_ssh_public_key(
+                InstanceId=self.instance_id,
+                InstanceOSUser='ec2-user',
+                SSHPublicKey=public_key
+            )
+            return True
+        except (ClientError, FileNotFoundError) as e:
+            self.log(f"Error pushing SSH key: {e}")
+            return False
+
+    def start_session(self) -> None:
+        """Start SSM session with SSH port forwarding.
+        
+        Uses AWS CLI directly to ensure proper stdin/stdout handling for SSH ProxyCommand.
+        The session manager plugin will automatically handle the data transfer.
+        
+        When used as a ProxyCommand, we need to:
+        1. Pass through stdin/stdout directly to AWS CLI
+        2. Only use stderr for logging
+        3. Let the session manager plugin handle the actual data transfer
+        """
+        import subprocess
+        import platform
+        
+        try:
+            # Build environment with AWS credentials configuration
+            env = os.environ.copy()
+            if 'AWS_CONFIG_FILE' in os.environ:
+                env['AWS_CONFIG_FILE'] = os.environ['AWS_CONFIG_FILE']
+            if 'AWS_SHARED_CREDENTIALS_FILE' in os.environ:
+                env['AWS_SHARED_CREDENTIALS_FILE'] = os.environ['AWS_SHARED_CREDENTIALS_FILE']
+            
+            # Determine AWS CLI command based on platform
+            aws_cmd = 'aws.exe' if platform.system() == 'Windows' else 'aws'
+            
+            # Build command as list (works for both Windows and Unix)
+            cmd = [
+                aws_cmd, 'ssm', 'start-session',
+                '--target', self.instance_id,
+                '--document-name', 'AWS-StartSSHSession',
+                '--parameters', f'portNumber={self.port}',
+                '--profile', self.profile,
+                '--region', self.session.region_name
+            ]
+            
+            # Start AWS CLI process with direct stdin/stdout pass-through
+            process = subprocess.Popen(
+                cmd,
+                env=env,
+                stdin=sys.stdin,
+                stdout=sys.stdout,
+                stderr=subprocess.PIPE,  # Capture stderr for our logging
+                shell=platform.system() == 'Windows'  # shell=True only on Windows
+            )
+            
+            # Monitor stderr for logging while process runs
+            while True:
+                err_line = process.stderr.readline()
+                if not err_line and process.poll() is not None:
+                    break
+                if err_line:
+                    self.log(err_line.decode().strip())
+            
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, cmd)
+            
+        except subprocess.CalledProcessError as e:
+            self.log(f"Error starting session: {e}")
+            raise
+
+    def connect(self) -> bool:
+        """Main connection flow:
+        1. Check instance status
+        2. Start if needed and wait for online
+        3. Push SSH key
+        4. Start SSM session
+        """
+        status = self.get_instance_status()
+        
+        if status != 'Online':
+            self.log(f"Instance {self.instance_id} is {status}, starting...")
+            if not self.start_instance():
+                return False
+            
+            self.log("Waiting for instance to come online...")
+            if not self.wait_for_instance():
+                self.log("Instance failed to come online")
+                return False
+        
+        self.log("Pushing SSH public key...")
+        if not self.push_ssh_key():
+            return False
+        
+        self.log("Starting SSM session...")
+        self.start_session()
+        return True

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-0.1.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 easytocloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cloudx_proxy-0.1.1.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.2
+Name: cloudx-proxy
+Version: 0.1.1
+Summary: SSH proxy command to connect VSCode with Cloud9/CloudX instance using AWS Systems Manager
+Author-email: easytocloud <info@easytocloud.com>
+License: MIT License
+        
+        Copyright (c) 2025 easytocloud
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/easytocloud/cloudX-proxy
+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
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: click>=8.1.0
+
+# cloudX-proxy
+
+A cross-platform SSH proxy command for connecting VSCode to CloudX/Cloud9 EC2 instances using AWS Systems Manager Session Manager.
+
+## Overview
+
+cloudX-proxy enables seamless SSH connections from VSCode to EC2 instances using AWS Systems Manager Session Manager, eliminating the need for direct SSH access or public IP addresses. It handles:
+
+- Automatic instance startup if stopped
+- SSH key distribution via EC2 Instance Connect
+- SSH tunneling through AWS Systems Manager
+- Cross-platform support (Windows, macOS, Linux)
+
+## Prerequisites
+
+1. **AWS CLI v2** - [Installation Guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+2. **AWS Session Manager Plugin** - [Installation Guide](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html)
+3. **OpenSSH Client**
+   - Windows: [Microsoft's OpenSSH Installation Guide](https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse?tabs=gui)
+   - macOS/Linux: Usually pre-installed
+4. **uv** - Python package installer and resolver
+   ```bash
+   pip install uv
+   ```
+5. **VSCode with Remote SSH Extension** installed
+
+## AWS Credentials Setup
+
+The proxy expects to find AWS credentials in a profile named 'vscode' by default. These credentials should be the Access Key and Secret Key that were created by deploying the cloudX-user stack in your AWS account. The cloudX-user stack creates an IAM user with the minimal permissions required for:
+- Starting/stopping EC2 instances
+- Establishing SSM sessions
+- Pushing SSH keys via EC2 Instance Connect
+
+Once the SSH session is established, the user has to further configure the instance using `generate-sso-config` tool. This is a one-time setup unless the user's access to AWS accounts changes, in which case the user should re-run the `generate-sso-config` tool.
+
+It is recommended to use  --generate-directories and --use-ou-structure to create working directories for each account the user has access to.
+
+Everytime the user connects to the instance, `ssostart` will authenticate the user with AWS SSO and generate temporary credentials. 
+
+This ensures you have the appropriate AWS access both for connecting to the instance and for working within it.
+
+The proxy also supports easytocloud's AWS profile organizer. If you use multiple AWS environments, you can store your AWS configuration and credentials in `~/.aws/aws-envs/<environment>` directories and use the `--aws-env` option to specify which environment to use.
+
+## Setup
+
+cloudX-proxy now includes a setup command that automates the entire configuration process:
+
+```bash
+# Basic setup with defaults (vscode profile and key)
+uvx cloudx-proxy setup
+
+# Setup with custom profile and key
+uvx cloudx-proxy setup --profile myprofile --ssh-key mykey
+
+# Setup with AWS environment
+uvx cloudx-proxy setup --aws-env prod
+```
+
+The setup command will:
+
+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
+
+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
+
+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
+
+4. Verify Instance Setup:
+   - Checks instance setup status
+   - Offers to wait for setup completion
+   - Monitors setup progress
+
+### Example SSH Configuration
+
+The setup command generates a configuration structure like this:
+
+```
+# 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
+```
+
+When adding new instances to an existing environment, the setup command will only add the specific host entry, preserving the existing environment configuration.
+
+### VSCode Configuration
+
+1. Install the "Remote - SSH" extension in VSCode
+2. Configure VSCode settings:
+   ```json
+   {
+       "remote.SSH.configFile": "~/.ssh/vscode/config",
+       "remote.SSH.connectTimeout": 90
+   }
+   ```
+
+## Usage
+
+### Command Line
+
+```bash
+# Setup new environment and instance
+uvx cloudx-proxy setup --profile myprofile --aws-env prod
+
+# Add instance to existing environment
+uvx cloudx-proxy setup --profile myprofile --aws-env prod
+
+# Connect to instance
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --profile myprofile --aws-env prod
+
+# Connect with custom port
+uvx cloudx-proxy connect i-0123456789abcdef0 2222 --profile myprofile
+
+# Connect with different region
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --region us-east-1
+
+# Connect with custom key
+uvx cloudx-proxy connect i-0123456789abcdef0 22 --key-path ~/.ssh/custom_key.pub
+```
+
+### VSCode
+
+1. Click the "Remote Explorer" icon in the VSCode sidebar
+2. Select "SSH Targets" from the dropdown
+3. Your configured hosts will appear (e.g., cloudx-dev)
+4. Click the "+" icon next to a host to connect
+5. VSCode will handle the rest, using cloudX-proxy to establish the connection
+
+## AWS Permissions
+
+The AWS user/role needs these permissions:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": [
+                "ec2:StartInstances",
+                "ec2:DescribeInstances",
+                "ssm:StartSession",
+                "ssm:DescribeInstanceInformation",
+                "ec2-instance-connect:SendSSHPublicKey"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
+```
+
+## Troubleshooting
+
+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
+
+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
+
+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-0.1.1.dist-info/RECORD

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

cloudx_proxy-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cloudx_proxy-0.1.1.dist-info/entry_points.txt

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

cloudx_proxy-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cloudx_proxy