cloudx-proxy 0.3.14__tar.gz → 0.4.0__tar.gz

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.4.0](https://github.com/easytocloud/cloudX-proxy/compare/v0.3.15...v0.4.0) (2025-03-06)
+
+
+### Features
+
+* added 1password integration ([4ac2340](https://github.com/easytocloud/cloudX-proxy/commit/4ac2340d6174ded129482e0fcd91a9cef0ab136d))
+
+## [0.3.15](https://github.com/easytocloud/cloudX-proxy/compare/v0.3.14...v0.3.15) (2025-03-06)
+
+
+### Bug Fixes
+
+* added --ssh-config ([893d919](https://github.com/easytocloud/cloudX-proxy/commit/893d919f7ef30dc5fd41a06b2c032d0035180e80))
+* added --ssh-config also in connect ([75b7b3b](https://github.com/easytocloud/cloudX-proxy/commit/75b7b3b5ecac5f1a1012ce9d4905bc5aed444915))
+
 ## [0.3.14](https://github.com/easytocloud/cloudX-proxy/compare/v0.3.13...v0.3.14) (2025-03-06)
 
 

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/PKG-INFO

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

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/cloudx_proxy/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.14'
-__version_tuple__ = version_tuple = (0, 3, 14)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/cloudx_proxy/cli.py

@@ -17,8 +17,9 @@ def cli():
 @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('--ssh-key', default='vscode', help='SSH key name to use (default: vscode)')
+@click.option('--ssh-config', help='SSH config file to use (default: ~/.ssh/vscode/config)')
 @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, ssh_key: str, aws_env: str):
+def connect(instance_id: str, port: int, profile: str, region: str, ssh_key: str, ssh_config: 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)
@@ -35,6 +36,7 @@ def connect(instance_id: str, port: int, profile: str, region: str, ssh_key: str
             profile=profile,
             region=region,
             ssh_key=ssh_key,
+            ssh_config=ssh_config,
             aws_env=aws_env
         )
         
@@ -48,8 +50,10 @@ def connect(instance_id: str, port: int, profile: str, region: str, ssh_key: str
 @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('--ssh-config', help='SSH config file to use (default: ~/.ssh/vscode/config)')
 @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):
+@click.option('--1password', 'use_1password', is_flag=True, help='Use 1Password SSH agent for SSH authentication')
+def setup(profile: str, ssh_key: str, ssh_config: str, aws_env: str, use_1password: bool):
     """Set up AWS profile, SSH keys, and configuration for CloudX.
     
     This command will:
@@ -61,9 +65,17 @@ def setup(profile: str, ssh_key: str, aws_env: str):
     Example usage:
         cloudx-proxy setup
         cloudx-proxy setup --profile myprofile --ssh-key mykey
+        cloudx-proxy setup --ssh-config ~/.ssh/cloudx/config
+        cloudx-proxy setup --1password
     """
     try:
-        setup = CloudXSetup(profile=profile, ssh_key=ssh_key, aws_env=aws_env)
+        setup = CloudXSetup(
+            profile=profile, 
+            ssh_key=ssh_key, 
+            ssh_config=ssh_config, 
+            aws_env=aws_env,
+            use_1password=use_1password
+        )
         
         print("\n\033[1;95m=== cloudx-proxy Setup ===\033[0m\n")
         

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/cloudx_proxy/core.py

@@ -7,7 +7,7 @@ from botocore.exceptions import ClientError
 
 class CloudXProxy:
     def __init__(self, instance_id: str, port: int = 22, profile: str = "vscode", 
-                 region: str = None, ssh_key: str = "vscode", aws_env: str = None):
+                 region: str = None, ssh_key: str = "vscode", ssh_config: str = None, aws_env: str = None):
         """Initialize CloudX client for SSH tunneling via AWS SSM.
         
         Args:
@@ -39,8 +39,14 @@ class CloudXProxy:
         self.ec2 = self.session.client('ec2')
         self.ec2_connect = self.session.client('ec2-instance-connect')
         
-        # Set up SSH key path
-        self.ssh_dir = os.path.expanduser("~/.ssh/vscode")
+        # Set up SSH configuration and key paths
+        if ssh_config:
+            self.ssh_config_file = os.path.expanduser(ssh_config)
+            self.ssh_dir = os.path.dirname(self.ssh_config_file)
+        else:
+            self.ssh_dir = os.path.expanduser("~/.ssh/vscode")
+            self.ssh_config_file = os.path.join(self.ssh_dir, "config")
+            
         self.ssh_key = os.path.join(self.ssh_dir, f"{ssh_key}.pub")
 
     def log(self, message: str) -> None:
@@ -85,9 +91,21 @@ class CloudXProxy:
         return False
 
     def push_ssh_key(self) -> bool:
-        """Push SSH public key to instance via EC2 Instance Connect."""
+        """Push SSH public key to instance via EC2 Instance Connect.
+        
+        Determines which SSH key to use (regular key or 1Password-managed key),
+        then pushes the correct public key to the instance.
+        """
         try:
-            with open(self.ssh_key) as f:
+            # Check if file exists with .pub extension (could be a non-1Password key)
+            # or if the .pub extension is already part of self.ssh_key (because of 1Password integration)
+            key_path = self.ssh_key
+            if not key_path.endswith('.pub'):
+                key_path += '.pub'
+                
+            self.log(f"Using public key: {key_path}")
+            
+            with open(key_path) as f:
                 public_key = f.read()
             
             self.ec2_connect.send_ssh_public_key(

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/cloudx_proxy/setup.py

@@ -9,20 +9,32 @@ import boto3
 from botocore.exceptions import ClientError
 
 class CloudXSetup:
-    def __init__(self, profile: str = "vscode", ssh_key: str = "vscode", aws_env: str = None):
+    def __init__(self, profile: str = "vscode", ssh_key: str = "vscode", ssh_config: str = None, 
+                 aws_env: str = None, use_1password: bool = False):
         """Initialize cloudx-proxy setup.
         
         Args:
             profile: AWS profile name (default: "vscode")
             ssh_key: SSH key name (default: "vscode")
+            ssh_config: SSH config file path (default: None, uses ~/.ssh/vscode/config)
             aws_env: AWS environment directory (default: None)
+            use_1password: Use 1Password SSH agent for authentication (default: False)
         """
         self.profile = profile
         self.ssh_key = ssh_key
         self.aws_env = aws_env
+        self.use_1password = use_1password
         self.home_dir = str(Path.home())
-        self.ssh_dir = Path(self.home_dir) / ".ssh" / "vscode"
-        self.ssh_config_file = self.ssh_dir / "config"
+        self.onepassword_agent_sock = Path(self.home_dir) / ".1password" / "agent.sock"
+        
+        # Set up ssh config paths based on provided config or default
+        if ssh_config:
+            self.ssh_config_file = Path(os.path.expanduser(ssh_config))
+            self.ssh_dir = self.ssh_config_file.parent
+        else:
+            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.default_env = None
 
@@ -143,6 +155,171 @@ class CloudXSetup:
             self.print_status(f"\033[1;91mError:\033[0m {str(e)}", False, 2)
             return False
 
+    def _check_1password_availability(self) -> bool:
+        """Check if 1Password CLI and SSH agent are available.
+        
+        Returns:
+            bool: True if 1Password is available and configured
+        """
+        if not self.use_1password:
+            return False
+            
+        self.print_status("Checking 1Password availability...")
+        
+        # Check if 1Password CLI is installed
+        try:
+            result = subprocess.run(
+                ['op', '--version'],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            if result.returncode != 0:
+                self.print_status("1Password CLI not found. Please install it from https://1password.com/downloads/command-line/", False, 2)
+                return False
+            
+            self.print_status(f"1Password CLI {result.stdout.strip()} installed", True, 2)
+            
+            # Check if 1Password SSH agent is running
+            agent_sock_exists = self.onepassword_agent_sock.exists()
+            if not agent_sock_exists:
+                self.print_status("1Password SSH agent socket not found at ~/.1password/agent.sock", False, 2)
+                self.print_status("Please ensure 1Password SSH agent is enabled in 1Password settings", None, 2)
+                return False
+                
+            self.print_status("1Password SSH agent socket found", True, 2)
+            
+            # Check if agent is active by trying to list identities
+            result = subprocess.run(
+                ['ssh-add', '-l'],
+                env={**os.environ, 'SSH_AUTH_SOCK': str(self.onepassword_agent_sock)},
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            if "Could not open a connection to your authentication agent" in result.stderr:
+                self.print_status("1Password SSH agent is not running", False, 2)
+                return False
+                
+            self.print_status("1Password SSH agent is running", True, 2)
+            
+            # Check if 1Password CLI is authenticated
+            result = subprocess.run(
+                ['op', 'account', 'list'],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            if result.returncode != 0:
+                self.print_status("1Password CLI is not authenticated. Run 'op signin' first.", False, 2)
+                return False
+                
+            self.print_status("1Password CLI is authenticated", True, 2)
+            return True
+            
+        except FileNotFoundError:
+            self.print_status("1Password CLI not found. Please install it from https://1password.com/downloads/command-line/", False, 2)
+            return False
+        except Exception as e:
+            self.print_status(f"Error checking 1Password: {str(e)}", False, 2)
+            return False
+
+    def _store_key_in_1password(self) -> bool:
+        """Store the SSH key in 1Password and offer to remove it from the filesystem.
+        
+        Returns:
+            bool: True if successful
+        """
+        try:
+            # If key exists on filesystem, offer to store it in 1Password
+            key_exists = self.ssh_key_file.exists() and (self.ssh_key_file.with_suffix('.pub')).exists()
+            
+            if not key_exists:
+                self.print_status("No SSH key found to store in 1Password", False, 2)
+                return False
+                
+            # Ask if user wants to store the key in 1Password
+            store_in_1password = self.prompt("Would you like to store this SSH key in 1Password?", "Y").lower() == "y"
+            if not store_in_1password:
+                return True
+                
+            # Get vault to store the key in
+            result = subprocess.run(
+                ['op', 'vault', 'list', '--format=json'],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            if result.returncode != 0:
+                self.print_status("Error listing 1Password vaults", False, 2)
+                return False
+                
+            vaults = json.loads(result.stdout)
+            if not vaults:
+                self.print_status("No 1Password vaults found", False, 2)
+                return False
+                
+            # Display available vaults
+            print("\n\033[96mAvailable 1Password vaults:\033[0m")
+            for i, vault in enumerate(vaults):
+                print(f"  {i+1}. {vault['name']}")
+                
+            # Let user select vault
+            vault_num = self.prompt("Select vault number to store SSH key", "1")
+            try:
+                vault_idx = int(vault_num) - 1
+                if vault_idx < 0 or vault_idx >= len(vaults):
+                    self.print_status("Invalid vault number", False, 2)
+                    return False
+                selected_vault = vaults[vault_idx]['id']
+            except ValueError:
+                self.print_status("Invalid input", False, 2)
+                return False
+                
+            # Read private key
+            private_key = self.ssh_key_file.read_text()
+            
+            # Create a title for the 1Password item
+            ssh_key_title = f"cloudX SSH Key - {self.ssh_key}"
+            
+            # Create item in 1Password
+            # Format: op item create --category=sshkey --title="..." --vault="..." "privateKey=<private key>"
+            result = subprocess.run(
+                [
+                    'op', 'item', 'create',
+                    '--category=sshkey',
+                    f'--title={ssh_key_title}',
+                    f'--vault={selected_vault}',
+                    f'privateKey={private_key}'
+                ],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            if result.returncode != 0:
+                self.print_status(f"Error storing SSH key in 1Password: {result.stderr}", False, 2)
+                return False
+                
+            self.print_status("SSH key stored in 1Password successfully", True, 2)
+            
+            # Ask if user wants to remove private key from filesystem
+            remove_private_key = self.prompt("Would you like to remove the private key from the filesystem? (for security)", "Y").lower() == "y"
+            if remove_private_key:
+                # We should only remove the private key, keep the public key
+                self.ssh_key_file.unlink()
+                self.print_status("Private key removed from filesystem", True, 2)
+                self.print_status("\033[93mImportant: If you need to recover this key, it's now only available in 1Password\033[0m", None, 2)
+                
+            return True
+            
+        except Exception as e:
+            self.print_status(f"Error storing key in 1Password: {str(e)}", False, 2)
+            return False
+
     def setup_ssh_key(self) -> bool:
         """Set up SSH key pair.
         
@@ -150,6 +327,34 @@ class CloudXSetup:
             bool: True if key was set up successfully
         """
         self.print_header("SSH Key Configuration")
+        
+        # Check 1Password integration if requested
+        if self.use_1password:
+            op_available = self._check_1password_availability()
+            if op_available:
+                self.print_status("Using 1Password SSH agent for authentication", True, 2)
+                
+                # Generate a key if it doesn't exist
+                key_exists = self.ssh_key_file.exists() and (self.ssh_key_file.with_suffix('.pub')).exists()
+                if not key_exists:
+                    self.print_status(f"No SSH key found for '{self.ssh_key}'", None, 2)
+                    create_key = self.prompt("Would you like to create a new SSH key?", "Y").lower() == "y"
+                    if create_key:
+                        # We'll continue to the standard key creation flow
+                        pass
+                    else:
+                        # User doesn't want a key, so we'll skip and just rely on 1Password
+                        return True
+                else:
+                    # Key exists, offer to store it in 1Password
+                    self._store_key_in_1password()
+                    return True
+            else:
+                proceed = self.prompt("1Password integration not available. Continue with standard SSH key setup?", "Y").lower() != "n"
+                if not proceed:
+                    return False
+                self.use_1password = False  # Fallback to standard setup
+        
         self.print_status(f"Checking SSH key '{self.ssh_key}' configuration...")
         
         try:
@@ -188,6 +393,14 @@ class CloudXSetup:
                     self.ssh_key_file.with_suffix('.pub').chmod(stat.S_IRUSR | stat.S_IWUSR | stat.S_IROTH | stat.S_IRGRP)  # 644 permissions
                     self.print_status("Set key file permissions", True, 2)
             
+            # For both standard setup and 1Password when a key needs to be created,
+            # we'll use the same code to generate the key
+            self.print_status("Key generated successfully", True, 2)
+            
+            # If using 1Password, offer to store the key there
+            if self.use_1password:
+                self._store_key_in_1password()
+                
             return True
 
         except Exception as e:
@@ -198,6 +411,75 @@ class CloudXSetup:
                 return True
             return False
 
+    def _build_proxy_command(self) -> str:
+        """Build the ProxyCommand with appropriate parameters.
+        
+        Returns:
+            str: The complete ProxyCommand string
+        """
+        proxy_command = "uvx cloudx-proxy connect %h %p"
+        if self.profile != "vscode":
+            proxy_command += f" --profile {self.profile}"
+        if self.aws_env:
+            proxy_command += f" --aws-env {self.aws_env}"
+        if self.ssh_key != "vscode":
+            proxy_command += f" --ssh-key {self.ssh_key}"
+            
+        return proxy_command
+        
+    def _build_auth_config(self) -> str:
+        """Build the authentication configuration block.
+        
+        Returns:
+            str: SSH config authentication section
+        """
+        if self.use_1password:
+            # When using 1Password:
+            # 1. Set IdentityAgent to the 1Password socket 
+            # 2. Set IdentityFile to the PUBLIC key (.pub) to limit key search
+            # 3. Set IdentitiesOnly to yes to avoid using ssh-agent keys
+            return f"""    IdentityAgent {self.onepassword_agent_sock}
+    IdentityFile {self.ssh_key_file}.pub
+    IdentitiesOnly yes
+"""
+        else:
+            # Standard SSH key configuration
+            return f"""    IdentityFile {self.ssh_key_file}
+    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.
+        
+        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
+        """
+        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
+"""
+        # Add authentication configuration
+        host_entry += self._build_auth_config()
+        
+        # Add proxy command if requested
+        if include_proxy:
+            host_entry += f"""    ProxyCommand {self._build_proxy_command()}
+"""
+        
+        return host_entry
+        
     def _add_host_entry(self, cloudx_env: str, instance_id: str, hostname: str, current_config: str) -> bool:
         """Add settings to a specific host entry.
         
@@ -211,25 +493,8 @@ class CloudXSetup:
             bool: True if settings were added successfully
         """
         try:
-            # Build host entry with all settings
-            proxy_command = "uvx cloudx-proxy connect %h %p"
-            if self.profile != "vscode":
-                proxy_command += f" --profile {self.profile}"
-            if self.aws_env:
-                proxy_command += f" --aws-env {self.aws_env}"
-            if self.ssh_key != "vscode":
-                proxy_command += f" --ssh-key {self.ssh_key}"
-
-            host_entry = f"""
-Host cloudx-{cloudx_env}-{hostname}
-    HostName {instance_id}
-    User ec2-user
-"""
-            host_entry += f"""    IdentityFile {self.ssh_key_file}
-    IdentitiesOnly yes
-"""
-            host_entry += f"""    ProxyCommand {proxy_command}
-"""
+            # 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:
@@ -330,8 +595,10 @@ Host cloudx-{cloudx_env}-{hostname}
                 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?\nSelect an option ",
+                        "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":
@@ -357,29 +624,18 @@ Host cloudx-{cloudx_env}-{hostname}
 
             # Create base config
             self.print_status(f"Creating new config for cloudx-{cloudx_env}-*", None, 2)
-            # Build ProxyCommand with only non-default parameters
-            proxy_command = "uvx cloudx-proxy connect %h %p"
-            if self.profile != "vscode":
-                proxy_command += f" --profile {self.profile}"
-            if self.aws_env:
-                proxy_command += f" --aws-env {self.aws_env}"
-            if self.ssh_key != "vscode":
-                proxy_command += f" --ssh-key {self.ssh_key}"
-
+            
             # Ensure control directory exists with proper permissions
             if not self._ensure_control_dir():
                 return False
             
-            # Build base configuration
-            base_config = f"""# cloudx-proxy SSH Configuration
-Host cloudx-{cloudx_env}-*
-    User ec2-user
-"""
-            # Add key configuration
-            base_config += f"""    IdentityFile {self.ssh_key_file}
-    IdentitiesOnly yes
-
-"""
+            # Build base configuration with wildcard hostname pattern
+            # Start with a header comment
+            base_config = "# cloudx-proxy SSH Configuration\n"
+            
+            # Add base host pattern with wildcard
+            base_config += self._build_host_config(cloudx_env, None, None, include_proxy=True)
+            
             # Add SSH multiplexing configuration
             control_path = "~/.ssh/control/%r@%h:%p"
             if platform.system() == 'Windows':
@@ -391,9 +647,6 @@ Host cloudx-{cloudx_env}-*
     ControlPath {control_path}
     ControlPersist 4h
 
-"""
-            # Add ProxyCommand
-            base_config += f"""    ProxyCommand {proxy_command}
 """
             
             # If file exists, append the new config, otherwise create it
@@ -410,17 +663,16 @@ Host cloudx-{cloudx_env}-*
                 self.ssh_config_file.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions (owner read/write)
                 self.print_status("Set config file permissions to 600", True, 2)
 
-            # Add specific host entry
+            # 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 = f"""
-Host cloudx-{cloudx_env}-{hostname}
-    HostName {instance_id}
-"""
+            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)
 
-            # Ensure main SSH config includes our config
+            # Handle system SSH config integration
+            system_config_path = Path(self.home_dir) / ".ssh" / "config"
+            
             # Ensure ~/.ssh directory has proper permissions
             ssh_parent_dir = Path(self.home_dir) / ".ssh"
             if not ssh_parent_dir.exists():
@@ -428,36 +680,41 @@ Host cloudx-{cloudx_env}-{hostname}
                 self.print_status(f"Created SSH directory: {ssh_parent_dir}", True, 2)
             self._set_directory_permissions(ssh_parent_dir)
             
-            main_config = Path(self.home_dir) / ".ssh" / "config"
-            include_line = f"Include {self.ssh_config_file}\n"
-            
-            if main_config.exists():
-                content = main_config.read_text()
-                if include_line not in content:
-                    with open(main_config, 'a') as f:
-                        f.write(f"\n{include_line}")
-                    self.print_status("Added include line to main SSH config", True, 2)
-                else:
-                    self.print_status("Main SSH config already includes our config", True, 2)
-                
-                # Set correct permissions on main config file
-                if platform.system() != 'Windows':
-                    import stat
-                    main_config.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
-                    self.print_status("Set main config file permissions to 600", True, 2)
+            # 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):
+                self.print_status("Using system SSH config directly, no Include needed", True, 2)
             else:
-                main_config.write_text(include_line)
-                self.print_status("Created main SSH config with include line", True, 2)
+                # Otherwise, make sure the system config includes our config file
+                include_line = f"Include {self.ssh_config_file}\n"
                 
-                # Set correct permissions on newly created main config file
-                if platform.system() != 'Windows':
-                    import stat
-                    main_config.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
-                    self.print_status("Set main config file permissions to 600", True, 2)
+                if system_config_path.exists():
+                    content = system_config_path.read_text()
+                    if include_line not in content:
+                        with open(system_config_path, 'a') as f:
+                            f.write(f"\n{include_line}")
+                        self.print_status("Added include line to system SSH config", True, 2)
+                    else:
+                        self.print_status("System SSH config already includes our config", True, 2)
+                    
+                    # Set correct permissions on system config file
+                    if platform.system() != 'Windows':
+                        import stat
+                        system_config_path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
+                        self.print_status("Set system config file permissions to 600", True, 2)
+                else:
+                    system_config_path.write_text(include_line)
+                    self.print_status("Created system SSH config with include line", True, 2)
+                    
+                    # Set correct permissions on newly created system config file
+                    if platform.system() != 'Windows':
+                        import stat
+                        system_config_path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
+                        self.print_status("Set system config file permissions to 600", True, 2)
 
             self.print_status("SSH configuration summary:", None)
-            self.print_status(f"Main config: {main_config}", None, 2)
+            self.print_status(f"System config: {system_config_path}", None, 2)
             self.print_status(f"cloudx-proxy config: {self.ssh_config_file}", None, 2)
+            self.print_status(f"SSH key directory: {self.ssh_dir}", None, 2)
             self.print_status(f"Connect using: ssh cloudx-{cloudx_env}-{hostname}", None, 2)
             
             return True

{cloudx_proxy-0.3.14 → cloudx_proxy-0.4.0}/cloudx_proxy.egg-info/PKG-INFO

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