cloudx-proxy 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

cloudx_proxy/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.2'
-__version_tuple__ = version_tuple = (0, 4, 2)
+__version__ = version = '0.4.4'
+__version_tuple__ = version_tuple = (0, 4, 4)

cloudx_proxy/cli.py

@@ -40,6 +40,8 @@ def connect(instance_id: str, port: int, profile: str, region: str, ssh_key: str
             aws_env=aws_env
         )
         
+        client.log(f"cloudx-proxy@{__version__} Connecting to instance {instance_id} on port {port}...")
+        
         if not client.connect():
             sys.exit(1)
             

cloudx_proxy/setup.py

@@ -346,6 +346,18 @@ class CloudXSetup:
                 return True
             return False
 
+    def _get_version(self) -> str:
+        """Get the current version of the cloudx-proxy package.
+        
+        Returns:
+            str: Version string
+        """
+        try:
+            from . import __version__
+            return __version__
+        except (ImportError, AttributeError):
+            return "unknown"
+    
     def _build_proxy_command(self) -> str:
         """Build the ProxyCommand with appropriate parameters.
         
@@ -383,38 +395,138 @@ class CloudXSetup:
     IdentitiesOnly yes
 """
 
-    def _build_host_config(self, cloudx_env: str, hostname: str, instance_id: str, include_proxy: bool = True) -> str:
-        """Build a host configuration block.
+    def _get_timestamp(self) -> str:
+        """Get a formatted timestamp for configuration comments.
+        
+        Returns:
+            str: Formatted timestamp
+        """
+        from datetime import datetime
+        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def _build_generic_config(self) -> str:
+        """Build a generic configuration block with common settings for all environments.
+        
+        Returns:
+            str: Generic configuration block
+        """
+        version = self._get_version()
+        timestamp = self._get_timestamp()
+        
+        # Start with metadata comment
+        config = f"""
+# Created by cloudx-proxy v{version} on {timestamp}
+# Configuration type: generic
+Host cloudx-*
+    User ec2-user
+    TCPKeepAlive yes
+"""
+        
+        # Add SSH multiplexing configuration
+        control_path = "~/.ssh/control/%r@%h:%p"
+        if platform.system() == 'Windows':
+            # Use forward slashes for Windows as well, SSH client will handle conversion
+            control_path = "~/.ssh/control/%r@%h:%p"
+            
+        config += f"""    ControlMaster auto
+    ControlPath {control_path}
+    ControlPersist 4h
+"""
+        
+        return config
+        
+    def _build_environment_config(self, cloudx_env: str) -> str:
+        """Build an environment-specific configuration block.
         
         Args:
             cloudx_env: CloudX environment
-            hostname: Hostname for the instance
-            instance_id: EC2 instance ID (None for wildcard entries)
-            include_proxy: Whether to include the ProxyCommand (default: True)
             
         Returns:
-            str: Complete host configuration block
+            str: Environment configuration block
         """
-        host_pattern = hostname if hostname else "*"
-        host_entry = f"""
-Host cloudx-{cloudx_env}-{host_pattern}
-"""
-        # Add HostName only for specific hosts, not for wildcard entries
-        if instance_id:
-            host_entry += f"""    HostName {instance_id}
-"""
-        host_entry += """    User ec2-user
+        version = self._get_version()
+        timestamp = self._get_timestamp()
+        
+        # Start with metadata comment
+        config = f"""
+# Created by cloudx-proxy v{version} on {timestamp}
+# Configuration type: environment
+Host cloudx-{cloudx_env}-*
 """
         # Add authentication configuration
-        host_entry += self._build_auth_config()
+        config += self._build_auth_config()
         
-        # Add proxy command if requested
-        if include_proxy:
-            host_entry += f"""    ProxyCommand {self._build_proxy_command()}
+        # Add ProxyCommand
+        config += f"""    ProxyCommand {self._build_proxy_command()}
 """
         
-        return host_entry
+        return config
         
+    def _build_host_config(self, cloudx_env: str, hostname: str, instance_id: str) -> str:
+        """Build a host-specific configuration block.
+        
+        Args:
+            cloudx_env: CloudX environment
+            hostname: Hostname for the instance
+            instance_id: EC2 instance ID
+            
+        Returns:
+            str: Host configuration block
+        """
+        version = self._get_version()
+        timestamp = self._get_timestamp()
+        
+        # Start with metadata comment
+        config = f"""
+# Created by cloudx-proxy v{version} on {timestamp}
+# Configuration type: host
+Host cloudx-{cloudx_env}-{hostname}
+    HostName {instance_id}
+"""
+        
+        return config
+    
+    def _check_config_exists(self, pattern: str, current_config: str) -> bool:
+        """Check if a configuration pattern exists in the current config.
+        
+        Args:
+            pattern: Host pattern to look for (e.g., 'cloudx-*', 'cloudx-dev-*')
+            current_config: Current SSH config content
+            
+        Returns:
+            bool: True if pattern exists in configuration
+        """
+        return f"Host {pattern}" in current_config
+    
+    def _extract_host_config(self, pattern: str, current_config: str) -> Tuple[str, str]:
+        """Extract a host configuration block from the current config.
+        
+        Args:
+            pattern: Host pattern to extract (e.g., 'cloudx-*', 'cloudx-dev-*')
+            current_config: Current SSH config content
+            
+        Returns:
+            Tuple[str, str]: Extracted host configuration, remaining configuration
+        """
+        lines = current_config.splitlines()
+        host_config_lines = []
+        remaining_lines = []
+        in_host_block = False
+        
+        for line in lines:
+            if line.strip() == f"Host {pattern}":
+                in_host_block = True
+                host_config_lines.append(line)
+            elif in_host_block and line.strip().startswith("Host "):
+                in_host_block = False
+                remaining_lines.append(line)
+            elif in_host_block:
+                host_config_lines.append(line)
+            else:
+                remaining_lines.append(line)
+                
+        return "\n".join(host_config_lines), "\n".join(remaining_lines)
+    
     def _add_host_entry(self, cloudx_env: str, instance_id: str, hostname: str, current_config: str) -> bool:
         """Add settings to a specific host entry.
         
@@ -428,13 +540,29 @@ Host cloudx-{cloudx_env}-{host_pattern}
             bool: True if settings were added successfully
         """
         try:
-            # Generate the host entry using the consolidated helper method
-            host_entry = self._build_host_config(cloudx_env, hostname, instance_id)
-            
-            # 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)
+            # Check if host entry already exists
+            host_pattern = f"cloudx-{cloudx_env}-{hostname}"
+            if self._check_config_exists(host_pattern, current_config):
+                # Extract existing host configuration
+                host_config, remaining_config = self._extract_host_config(host_pattern, current_config)
+                
+                # Update host configuration
+                host_config = self._build_host_config(cloudx_env, hostname, instance_id)
+                
+                # Write updated config
+                with open(self.ssh_config_file, 'w') as f:
+                    f.write(remaining_config)
+                    f.write(host_config)
+                
+                self.print_status(f"Updated existing host entry for {host_pattern}", True, 2)
+            else:
+                # Generate new host entry
+                host_entry = self._build_host_config(cloudx_env, hostname, instance_id)
+                
+                # Append host entry
+                with open(self.ssh_config_file, 'a') as f:
+                    f.write(host_entry)
+                self.print_status(f"Added new host entry for {host_pattern}", True, 2)
             
             # Set proper permissions on the config file
             if platform.system() != 'Windows':
@@ -451,6 +579,81 @@ Host cloudx-{cloudx_env}-{host_pattern}
                 self.print_status("Continuing setup despite SSH config issues", None, 2)
                 return True
             return False
+    
+    def _check_and_create_generic_config(self, current_config: str) -> Tuple[bool, str]:
+        """Check if generic configuration exists and create it if needed.
+        
+        Args:
+            current_config: Current SSH config content
+            
+        Returns:
+            Tuple[bool, str]: Success flag, Updated configuration
+        """
+        if self._check_config_exists("cloudx-*", current_config):
+            self.print_status("Found existing generic config for cloudx-*", True, 2)
+            return True, current_config
+        
+        self.print_status("Creating generic config for cloudx-*", None, 2)
+        generic_config = self._build_generic_config()
+        
+        # Append generic config to current config
+        updated_config = current_config
+        if updated_config and not updated_config.endswith('\n'):
+            updated_config += '\n'
+        updated_config += generic_config
+        
+        return True, updated_config
+        
+    def _check_and_create_environment_config(self, cloudx_env: str, current_config: str) -> Tuple[bool, str]:
+        """Check if environment configuration exists and create it if needed.
+        
+        Args:
+            cloudx_env: CloudX environment
+            current_config: Current SSH config content
+            
+        Returns:
+            Tuple[bool, str]: Success flag, Updated configuration
+        """
+        if self._check_config_exists(f"cloudx-{cloudx_env}-*", current_config):
+            self.print_status(f"Found existing config for cloudx-{cloudx_env}-*", True, 2)
+            
+            # Option to override if needed
+            choice = self.prompt(
+                "Would you like to \n"
+                "  1: override the existing environment config\n"
+                "  2: keep existing environment config?\n"
+                "Select an option",
+                "2"
+            )
+            
+            if choice == "1":
+                # Remove existing config for this environment
+                self.print_status("Removing existing environment configuration", None, 2)
+                env_config, remaining_config = self._extract_host_config(f"cloudx-{cloudx_env}-*", current_config)
+                
+                # Create new environment config
+                env_config = self._build_environment_config(cloudx_env)
+                
+                # Append new environment config to remaining config
+                updated_config = remaining_config
+                if updated_config and not updated_config.endswith('\n'):
+                    updated_config += '\n'
+                updated_config += env_config
+                
+                return True, updated_config
+            
+            return True, current_config
+        
+        self.print_status(f"Creating environment config for cloudx-{cloudx_env}-*", None, 2)
+        env_config = self._build_environment_config(cloudx_env)
+        
+        # Append environment config to current config
+        updated_config = current_config
+        if updated_config and not updated_config.endswith('\n'):
+            updated_config += '\n'
+        updated_config += env_config
+        
+        return True, updated_config
 
     def _ensure_control_dir(self) -> bool:
         """Create SSH control directory with proper permissions.
@@ -478,38 +681,21 @@ Host cloudx-{cloudx_env}-{host_pattern}
             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
-           - SSH multiplexing configuration (ControlMaster, ControlPath, ControlPersist)
-        
-        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
-            TCPKeepAlive yes
-            ControlMaster auto
-            ControlPath ~/.ssh/control/%r@%h:%p
-            ControlPersist 4h
-            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
-        ```
+        """Set up SSH config for the instance using a three-tier configuration approach.
+        
+        This method implements a hierarchical SSH configuration with three levels:
+        1. Generic (cloudx-*): Common settings for all environments
+           - User settings
+           - TCP keepalive
+           - SSH multiplexing configuration
+        
+        2. Environment (cloudx-{env}-*): Environment-specific settings
+           - Authentication configuration (identity settings)
+           - ProxyCommand with environment-specific parameters
+        
+        3. Host (cloudx-{env}-hostname): Instance-specific settings
+           - HostName (instance ID)
+           - Optional overrides for incompatible settings
         
         Args:
             cloudx_env: CloudX environment (e.g., dev, prod)
@@ -520,91 +706,46 @@ Host cloudx-{cloudx_env}-{host_pattern}
             bool: True if config was set up successfully
         """
         self.print_header("SSH Configuration")
-        self.print_status("Setting up SSH configuration...")
+        self.print_status("Setting up SSH configuration with three-tier approach...")
         
         try:
-            # Check existing configuration
-            if self.ssh_config_file.exists():
-                current_config = self.ssh_config_file.read_text()
-                # Check if configuration for this environment already exists
-                if f"Host cloudx-{cloudx_env}-*" in current_config:
-                    self.print_status(f"Found existing config for cloudx-{cloudx_env}-*", True, 2)
-                    choice = self.prompt(
-                        "Would you like to \n"
-                        "  1: override the existing config\n"
-                        "  2: add settings to the specific host entry?\n"
-                        "Select an option",
-                        "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)
-            
             # Ensure control directory exists with proper permissions
             if not self._ensure_control_dir():
                 return False
             
-            # Build base configuration with wildcard hostname pattern
-            # Start with a header comment
-            base_config = "# cloudx-proxy SSH Configuration\n"
+            # Initialize or read current configuration
+            current_config = ""
+            if self.ssh_config_file.exists():
+                current_config = self.ssh_config_file.read_text()
             
-            # Add base host pattern with wildcard
-            base_config += self._build_host_config(cloudx_env, None, None, include_proxy=True)
+            # 1. Check and create generic config (highest level)
+            self.print_status("Checking generic configuration...", None, 2)
+            success, current_config = self._check_and_create_generic_config(current_config)
+            if not success:
+                return False
             
-            # Add SSH multiplexing configuration
-            control_path = "~/.ssh/control/%r@%h:%p"
-            if platform.system() == 'Windows':
-                # Use forward slashes for Windows as well, SSH client will handle conversion
-                control_path = "~/.ssh/control/%r@%h:%p"
+            # 2. Check and create environment config
+            self.print_status("Checking environment configuration...", None, 2)
+            success, current_config = self._check_and_create_environment_config(cloudx_env, current_config)
+            if not success:
+                return False
                 
-            base_config += f"""    TCPKeepAlive yes
-    ControlMaster auto
-    ControlPath {control_path}
-    ControlPersist 4h
-
-"""
-            
-            # 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)
+            # Write the updated config with generic and environment tiers
+            self.ssh_config_file.parent.mkdir(parents=True, exist_ok=True)
+            self.ssh_config_file.write_text(current_config)
+            self.print_status("Generic and environment configurations created", True, 2)
             
             # Set proper permissions on the config file
             if platform.system() != 'Windows':
                 import stat
-                self.ssh_config_file.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions (owner read/write)
+                self.ssh_config_file.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
                 self.print_status("Set config file permissions to 600", True, 2)
-
-            # Add specific host entry using the consolidated helper method
-            self.print_status(f"Adding host entry for cloudx-{cloudx_env}-{hostname}", None, 2)
-            host_entry = self._build_host_config(cloudx_env, hostname, instance_id, include_proxy=False)
-            with open(self.ssh_config_file, 'a') as f:
-                f.write(host_entry)
-            self.print_status("Host entry added", True, 2)
-
+            
+            # 3. Add or update host entry (lowest level)
+            self.print_status(f"Adding/updating host entry for cloudx-{cloudx_env}-{hostname}", None, 2)
+            if not self._add_host_entry(cloudx_env, instance_id, hostname, current_config):
+                return False
+            
             # Handle system SSH config integration
             system_config_path = Path(self.home_dir) / ".ssh" / "config"
             
@@ -615,8 +756,17 @@ Host cloudx-{cloudx_env}-{host_pattern}
                 self.print_status(f"Created SSH directory: {ssh_parent_dir}", True, 2)
             self._set_directory_permissions(ssh_parent_dir)
             
-            # If our config file is the system config, we're done
-            if self.ssh_config_file.samefile(system_config_path) if self.ssh_config_file.exists() and system_config_path.exists() else str(self.ssh_config_file) == str(system_config_path):
+            # Handle system config integration
+            same_file = False
+            if self.ssh_config_file.exists() and system_config_path.exists():
+                try:
+                    same_file = self.ssh_config_file.samefile(system_config_path)
+                except:
+                    same_file = str(self.ssh_config_file) == str(system_config_path)
+            else:
+                same_file = str(self.ssh_config_file) == str(system_config_path)
+                
+            if same_file:
                 self.print_status("Using system SSH config directly, no Include needed", True, 2)
             else:
                 # Otherwise, make sure the system config includes our config file

{cloudx_proxy-0.4.2.dist-info → cloudx_proxy-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cloudx-proxy
-Version: 0.4.2
+Version: 0.4.4
 Summary: SSH proxy command to connect VSCode with Cloud9/CloudX instance using AWS Systems Manager
 Author-email: easytocloud <info@easytocloud.com>
 License: MIT License
@@ -112,6 +112,15 @@ uvx cloudx-proxy setup --profile myprofile --ssh-key mykey
 
 # Setup with AWS environment
 uvx cloudx-proxy setup --aws-env prod
+
+# Setup with custom SSH config location
+uvx cloudx-proxy setup --ssh-config ~/.ssh/cloudx/config
+
+# Setup with 1Password integration
+uvx cloudx-proxy setup --1password
+
+# Combine options
+uvx cloudx-proxy setup --profile myprofile --ssh-key mykey --ssh-config ~/.ssh/cloudx/config --1password --aws-env prod
 ```
 
 The setup command will:
@@ -123,13 +132,16 @@ The setup command will:
 
 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
+   - Fully supports 1Password integration:
+     * Using 1Password SSH agent via `--1password` flag
+     * Creates keys directly in 1Password's secure vault
+     * Only public keys are exported to the filesystem
+     * Follows SSH best practices using public keys to limit authentication attempts
 
 3. Configure SSH:
-   - Creates ~/.ssh/vscode/config with proper settings
-   - Sets up environment-specific configurations
+   - Creates SSH configs with proper settings (default: ~/.ssh/vscode/config)
+   - Custom config location can be specified with `--ssh-config`
+   - Sets up optimized environment-specific configurations
    - Configures ProxyCommand with all necessary parameters
    - Ensures main ~/.ssh/config includes the configuration
 
@@ -146,16 +158,30 @@ The setup command configures SSH to use cloudX-proxy as a ProxyCommand, enabling
 uvx cloudx-proxy setup --profile myprofile --ssh-key mykey
 ```
 
-Will create a configuration like this:
+Will create a three-tier configuration structure like this:
 
 ```
-# Base environment config (created once per environment)
-Host cloudx-dev-*
+# Generic configuration (shared by all environments)
+# Created by cloudx-proxy v1.0.0 on 2025-03-07 09:05:23
+# Configuration type: generic
+Host cloudx-*
     User ec2-user
+    TCPKeepAlive yes
+    ControlMaster auto
+    ControlPath ~/.ssh/control/%r@%h:%p
+    ControlPersist 4h
+
+# Environment configuration (specific to a single environment)
+# Created by cloudx-proxy v1.0.0 on 2025-03-07 09:05:23
+# Configuration type: environment
+Host cloudx-dev-*
     IdentityFile ~/.ssh/vscode/mykey
+    IdentitiesOnly yes
     ProxyCommand uvx cloudx-proxy connect %h %p --profile myprofile --ssh-key mykey
 
-# Host entry (added for specific instance)
+# Host configuration (specific to a single instance)
+# Created by cloudx-proxy v1.0.0 on 2025-03-07 09:05:23
+# Configuration type: host
 Host cloudx-dev-myserver
     HostName i-0123456789abcdef0
 ```
@@ -173,21 +199,30 @@ In these examples, ssh will use cloudx-proxy to connect to AWS with the `myprofi
 VSCode will be able to connect to the instance using the same SSH configuration.
 
 ### SSH Configuration Details
-The setup command creates:
+The setup command creates a hierarchical three-tier SSH configuration structure:
 
-1. A base configuration for each environment (cloudx-{env}-*) with:
-   - User and key settings
-   - 1Password integration if selected
-   - ProxyCommand with appropriate parameters
+1. Generic configuration (cloudx-*) containing common settings shared across all environments:
+   - User settings (ec2-user)
+   - TCP keepalive for connection stability
+   - SSH multiplexing for better performance (ControlMaster, ControlPath, ControlPersist)
 
-2. Individual host entries for each instance:
-   - Uses consistent naming (cloudx-{env}-hostname)
-   - Maps to instance IDs automatically
-   - Inherits environment-level settings
+2. Environment-specific configuration (cloudx-{env}-*) with:
+   - Authentication settings (IdentityFile, IdentityAgent for 1Password)
+   - ProxyCommand with environment-specific parameters
+   - Inherits all settings from the generic configuration
+
+3. Host-specific entries (cloudx-{env}-hostname) with:
+   - Instance ID (HostName directive)
+   - Inherits all settings from both generic and environment configurations
+
+Each configuration tier is clearly marked with a timestamp and version information comment, making it easy to track when and how configurations were created.
 
 When adding new instances to an existing environment, you can choose to:
+- Keep the existing environment configuration if it's compatible
 - Override the environment configuration with new settings
-- Add instance-specific settings while preserving the environment config
+- Add host-specific settings only
+
+This three-tier structure offers better maintainability by reducing duplication and making it clear which settings apply broadly and which are specific to an environment or host.
 
 ### VSCode Configuration
 
@@ -211,7 +246,9 @@ uvx cloudx-proxy setup [OPTIONS]
 
 Options:
 - `--profile` (default: vscode): AWS profile to use. The profile's IAM user should follow the format cloudX-{env}-{user}. The environment part will be used as the default environment during setup.
-- `--ssh-key` (default: vscode): Name of the SSH key to create/use. The key will be stored in ~/.ssh/vscode/{name}. This same name can be used in the connect command.
+- `--ssh-key` (default: vscode): Name of the SSH key to create/use. The key will be stored in the SSH config directory. This same name can be used in the connect command.
+- `--ssh-config` (optional): Path to the SSH config file to use. If specified, configuration and keys will be stored in this location. Default is ~/.ssh/vscode/config.
+- `--1password` (flag): Enable 1Password SSH agent integration. Creates keys directly in 1Password and configures SSH to use the 1Password SSH agent.
 - `--aws-env` (optional): AWS environment directory to use. If specified, AWS configuration and credentials will be read from ~/.aws/aws-envs/{env}/.
 
 Example usage:
@@ -222,8 +259,11 @@ 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 --profile myprofile --aws-env prod
+# Setup with custom SSH config and 1Password integration
+uvx cloudx-proxy setup --ssh-config ~/.ssh/cloudx/config --1password
+
+# Complete setup with all options
+uvx cloudx-proxy setup --profile myprofile --ssh-key mykey --ssh-config ~/.ssh/cloudx/config --1password --aws-env prod
 ```
 
 #### Connect Command
@@ -238,6 +278,7 @@ Arguments:
 Options:
 - `--profile` (default: vscode): AWS profile to use. Should match the profile used in setup.
 - `--ssh-key` (default: vscode): Name of the SSH key to use. Should match the key name used in setup.
+- `--ssh-config` (optional): Path to the SSH config file to use. If provided during setup, should match here.
 - `--region` (optional): AWS region to use. If not specified, uses the region from the AWS profile.
 - `--aws-env` (optional): AWS environment directory to use. Should match the environment used in setup.
 
@@ -303,12 +344,17 @@ These permissions are required to bootstrap the instance, so that after creation
    - Check that your AWS credentials have the required permissions
    - Verify the instance ID is correct
    - Increase the VSCode SSH timeout if needed
+   - Check if the instance is starting up (can take several minutes)
 
 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
+   - For 1Password-managed keys, make sure:
+     * 1Password CLI is installed and authenticated (`op account list` works)
+     * SSH agent is enabled in 1Password settings
+     * Keys are added to the SSH agent in 1Password
+     * The key is visible with `op item list --categories "SSH Key"`
 
 4. **AWS Configuration**
    - Confirm AWS CLI is configured with valid credentials

cloudx_proxy-0.4.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+cloudx_proxy/_1password.py,sha256=uxyCfVvO1eQrOfYRojst_LN2DV4fIwxM5moaQTn3wQY,5853
+cloudx_proxy/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
+cloudx_proxy/_version.py,sha256=rQpExgwkkSMYhPbtDdfhSejoe7mM9tgzyWoNno0mgIw,511
+cloudx_proxy/cli.py,sha256=5IcfYFACUOa4pqSKuHucqZionI9P8n5ZLvtzyXYeTvw,4218
+cloudx_proxy/core.py,sha256=RF3bX5MQiokRKjYEPnfWdKywGdtoVUvV2xZqm9uOl1g,8135
+cloudx_proxy/setup.py,sha256=11DsAVt6L4d3VmuJNpU07-QdF3FwahOUpJyLDksMeaE,38216
+cloudx_proxy-0.4.4.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
+cloudx_proxy-0.4.4.dist-info/METADATA,sha256=22Yrnn7514Dd8eYte1c03xXpSjMhgATvwIftn1A95iQ,16757
+cloudx_proxy-0.4.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+cloudx_proxy-0.4.4.dist-info/entry_points.txt,sha256=HGt743N2lVlKd7O1qWq3C0aEHyS5PjPnxzDHh7hwtSg,54
+cloudx_proxy-0.4.4.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
+cloudx_proxy-0.4.4.dist-info/RECORD,,

cloudx_proxy-0.4.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-cloudx_proxy/_1password.py,sha256=uxyCfVvO1eQrOfYRojst_LN2DV4fIwxM5moaQTn3wQY,5853
-cloudx_proxy/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
-cloudx_proxy/_version.py,sha256=_F8vLxUxrAtC2alXNPGVa9l3P6_vLpQAzemS6QlnPGQ,511
-cloudx_proxy/cli.py,sha256=kdrZydxL94BJrv6NnjIcceRqhoonBzMIx4vfm1Wl7qc,4104
-cloudx_proxy/core.py,sha256=RF3bX5MQiokRKjYEPnfWdKywGdtoVUvV2xZqm9uOl1g,8135
-cloudx_proxy/setup.py,sha256=jvv7ibJQ8svyjYYeVKwGa70L7RV2W7yS7JXEvKed3wI,33339
-cloudx_proxy-0.4.2.dist-info/LICENSE,sha256=i7P2OR4zsJYsMWcCUDe_B9ZfGi9bU0K5I2nKfDrW_N8,1068
-cloudx_proxy-0.4.2.dist-info/METADATA,sha256=YAHtMfsqZ1aDk1FryZhgV-Q_vr4GcdBO_mzs-gbEpK8,14037
-cloudx_proxy-0.4.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-cloudx_proxy-0.4.2.dist-info/entry_points.txt,sha256=HGt743N2lVlKd7O1qWq3C0aEHyS5PjPnxzDHh7hwtSg,54
-cloudx_proxy-0.4.2.dist-info/top_level.txt,sha256=2wtEote1db21j-VvkCJFfT-dLlauuG5indjggYh3xDg,13
-cloudx_proxy-0.4.2.dist-info/RECORD,,