utils_devops 0.1.130__tar.gz → 0.1.136__tar.gz

{utils_devops-0.1.130 → utils_devops-0.1.136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utils_devops
-Version: 0.1.130
+Version: 0.1.136
 Summary: Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools
 License: MIT
 Keywords: devops,automation,nginx,cli,jinja2,yaml,config,diff,templating,logging,docker,compose,file-ops

{utils_devops-0.1.130 → utils_devops-0.1.136}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "utils_devops"
-version = "0.1.130"  # Bumped for new string features + diffing
+version = "0.1.136"  # Bumped for new string features + diffing
 description = "Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools"
 authors = ["Hamed Sheikhan <sh.sheikhan.m@gmail.com>"]
 license = "MIT"

{utils_devops-0.1.130 → utils_devops-0.1.136}/src/utils_devops/extras/ssh_ops.py

@@ -340,18 +340,35 @@ def ssh_connect(
         key_path, key_content = _resolve_ssh_key(key_file)
         
         if key_content:
+            # **FIXED HERE**: Ensure proper line endings in the key content
+            # SSH keys MUST have newlines at specific positions
+            key_content = _normalize_ssh_key_content(key_content)
+            
             # Create temporary file for key content
             import tempfile
             temp_key_file = tempfile.NamedTemporaryFile(
-                mode='w',
+                mode='w',  # Text mode for proper newline handling
                 suffix='_ssh_key',
-                delete=False
+                delete=False,
+                newline='\n'  # Explicitly use LF newlines
             )
+            
+            # **CRITICAL FIX**: Write with proper line endings
             temp_key_file.write(key_content)
+            temp_key_file.flush()  # Ensure data is written
+            os.fsync(temp_key_file.fileno())  # Force sync to disk
             temp_key_file.close()
             
-            # Set permissions
+            # Set strict permissions for SSH keys
             os.chmod(temp_key_file.name, 0o600)
+            
+            # **DEBUG**: Verify what was written
+            with open(temp_key_file.name, 'r') as f:
+                written_content = f.read()
+                _logger.debug(f"Written key length: {len(written_content)}")
+                _logger.debug(f"Key first 100 chars: {written_content[:100]}")
+                _logger.debug(f"Key lines: {written_content.count(chr(10))}")
+            
             connect_kwargs['key_filename'] = temp_key_file.name
             _logger.debug(f"Using temporary SSH key file: {temp_key_file.name}")
             
@@ -390,8 +407,8 @@ def ssh_connect(
             try:
                 os.unlink(temp_key_file.name)
                 _logger.debug(f"Cleaned up temporary key file: {temp_key_file.name}")
-            except:
-                pass
+            except Exception as e:
+                _logger.warning(f"Failed to cleanup temp key file: {e}")
         
         if client:
             try:
@@ -400,6 +417,117 @@ def ssh_connect(
             except:
                 pass
 
+
+def _normalize_ssh_key_content(key_content: str) -> str:
+    """
+    Normalize SSH key content to ensure proper formatting.
+    
+    SSH keys require specific line breaks:
+    - Must start with -----BEGIN ...-----
+    - Base64 content should be on separate lines (64 chars max per line)
+    - Must end with -----END ...-----
+    
+    Args:
+        key_content: Raw key content (may be single line or malformed)
+    
+    Returns:
+        Properly formatted SSH key
+    """
+    # If already looks properly formatted, return as-is
+    if "-----BEGIN" in key_content and "-----END" in key_content and '\n' in key_content:
+        # Verify line endings
+        lines = key_content.splitlines()
+        if len(lines) > 1:
+            return key_content
+    
+    # Parse and reformat
+    lines = []
+    current_line = []
+    
+    # Remove all existing whitespace and split
+    clean_content = key_content.strip()
+    
+    if clean_content.startswith("-----BEGIN"):
+        # Extract header
+        header_end = clean_content.find("-----", 10) + 5
+        header = clean_content[:header_end]
+        lines.append(header)
+        
+        # Get base64 content between headers
+        base64_start = header_end
+        base64_end = clean_content.find("-----END")
+        base64_content = clean_content[base64_start:base64_end].strip()
+        
+        # Remove all whitespace from base64
+        base64_clean = ''.join(base64_content.split())
+        
+        # Split into 64 character lines (standard for SSH keys)
+        for i in range(0, len(base64_clean), 64):
+            lines.append(base64_clean[i:i+64])
+        
+        # Add footer
+        footer_start = base64_end
+        lines.append(clean_content[footer_start:].strip())
+    else:
+        # Assume it's just base64, wrap in OpenSSH header/footer
+        lines.append("-----BEGIN OPENSSH PRIVATE KEY-----")
+        clean_base64 = ''.join(clean_content.split())
+        for i in range(0, len(clean_base64), 64):
+            lines.append(clean_base64[i:i+64])
+        lines.append("-----END OPENSSH PRIVATE KEY-----")
+    
+    return '\n'.join(lines) + '\n'
+
+
+# Also update your _resolve_ssh_key function to preserve newlines:
+def _resolve_ssh_key(key_input: Optional[Union[str, Path]]) -> Tuple[Optional[Path], Optional[str]]:
+    """
+    Resolve SSH key input to either a file path or key content.
+    
+    Args:
+        key_input: Could be:
+            - Path to key file
+            - Environment variable name ($VAR)
+            - Raw key content string
+    
+    Returns:
+        Tuple of (file_path, key_content)
+    """
+    if not key_input:
+        return None, None
+    
+    # If it's a Path object
+    if isinstance(key_input, Path):
+        if key_input.exists():
+            return key_input, None
+        else:
+            raise FileNotFoundError(f"SSH key file not found: {key_input}")
+    
+    key_input_str = str(key_input)
+    
+    # Check if it's an environment variable reference
+    if key_input_str.startswith('$'):
+        env_var = key_input_str[1:]
+        key_content = os.environ.get(env_var)
+        if not key_content:
+            raise ValueError(f"Environment variable not set: {env_var}")
+        
+        # **CRITICAL**: Don't strip newlines from env var content!
+        # SSH keys in env vars often have escaped newlines (\n)
+        # Replace literal \n with actual newlines
+        if '\\n' in key_content:
+            key_content = key_content.replace('\\n', '\n')
+        
+        return None, key_content
+    
+    # Check if it's a file path
+    if os.path.exists(key_input_str):
+        return Path(key_input_str), None
+    
+    # Assume it's raw key content
+    # **IMPORTANT**: Preserve any newlines in the content
+    return None, key_input_str
+
 def ssh_execute_command(
     host: str,
     command: Union[str, List[str]],
@@ -1465,10 +1593,10 @@ def validate_machine_config(machine: MachineConfig) -> List[str]:
             errors.append(f"Invalid deploy_dir format: {e}")
     
     # Validate key file if specified
-    if machine.key_file:
-        key_path = Path(machine.key_file).expanduser()
-        if not key_path.exists():
-            errors.append(f"SSH key file not found: {key_path}")
+    # if machine.key_file:
+    #     key_path = Path(machine.key_file).expanduser()
+    #     if not key_path.exists():
+    #         errors.append(f"SSH key file not found: {key_path}")
     
     return errors