Merge pull request #14 from samzong/feature/comprehensive-ssh-config

feat: Implement comprehensive SSH configuration support

Author: samzong

CLI/README.md

@@ -30,6 +30,14 @@ Connect to an SSH host:
 cf ssh connect <host-name>
 ```
 
+Show all configured directives for a specific SSH host:
+```bash
+cf ssh show <host-name>
+# or
+cf ssh s <host-name>
+```
+This command displays every directive (e.g., HostName, User, Port, IdentityFile, as well as any custom options) defined for the specified host in your `~/.ssh/config` file.
+
 ### Kubernetes Commands
 
 List all Kubernetes contexts:

CLI/Sources/ConfigForgeCLI/Commands/SSHCommand.swift

@@ -41,28 +41,14 @@ struct SSHListCommand: ParsableCommand {
 
             print("Available SSH hosts:")
             for (index, entry) in entries.enumerated() {
-                let hostName = entry.host ?? "unnamed"
+                let hostName = entry.host
                 let number = index + 1
 
                 if detail {
                     print("  \(number). \(hostName)")
-                    if let user = entry.user {
-                        print("      User: \(user)")
-                    }
-                    if let hostname = entry.hostname {
-                        print("      Hostname: \(hostname)")
-                    }
-                    if let port = entry.port {
-                        print("      Port: \(port)")
-                    }
-                    if let identityFile = entry.identityFile {
-                        print("      IdentityFile: \(identityFile)")
-                    }
-                    if let forwardAgent = entry.forwardAgent {
-                        print("      ForwardAgent: \(forwardAgent)")
-                    }
-                    if let proxyCommand = entry.proxyCommand {
-                        print("      ProxyCommand: \(proxyCommand)")
+                    // Display all directives for this host
+                    for directive in entry.directives {
+                        print("      \(directive.key): \(directive.value)")
                     }
                     print("")
                 } else {
@@ -113,47 +99,11 @@ struct SSHShowCommand: ParsableCommand {
                 entry = foundEntry
             }
 
-            print("Host: \(entry.host ?? "unnamed")")
-            
-            if let hostname = entry.hostname {
-                print("   Hostname: \(hostname)")
-            }
-            if let user = entry.user {
-                print("   User: \(user)")
-            }
-            if let port = entry.port {
-                print("   Port: \(port)")
-            }
-            if let identityFile = entry.identityFile {
-                print("   IdentityFile: \(identityFile)")
-            }
-            if let forwardAgent = entry.forwardAgent {
-                print("   ForwardAgent: \(forwardAgent)")
-            }
-            if let proxyCommand = entry.proxyCommand {
-                print("   ProxyCommand: \(proxyCommand)")
-            }
-            if let serverAliveInterval = entry.serverAliveInterval {
-                print("   ServerAliveInterval: \(serverAliveInterval)")
-            }
-            if let serverAliveCountMax = entry.serverAliveCountMax {
-                print("   ServerAliveCountMax: \(serverAliveCountMax)")
-            }
-            if let strictHostKeyChecking = entry.strictHostKeyChecking {
-                print("   StrictHostKeyChecking: \(strictHostKeyChecking)")
-            }
-            if let userKnownHostsFile = entry.userKnownHostsFile {
-                print("   UserKnownHostsFile: \(userKnownHostsFile)")
-            }
-            if let connectTimeout = entry.connectTimeout {
-                print("   ConnectTimeout: \(connectTimeout)")
-            }
+            print("Host: \(entry.host)")
 
-            if !entry.otherOptions.isEmpty {
-                print("   Other Options:")
-                for (key, value) in entry.otherOptions {
-                    print("      \(key): \(value)")
-                }
+            // Iterate through all directives and print them
+            for directive in entry.directives {
+                print("   \(directive.key): \(directive.value)")
             }
         } catch {
             print("Error: \(error.localizedDescription)")
@@ -188,7 +138,7 @@ struct SSHConnectCommand: ParsableCommand {
             // Check if input is a number
             if let index = Int(host), index > 0, index <= entries.count {
                 hostEntry = entries[index - 1]
-                hostDisplayName = "\(index). \(hostEntry.host ?? "unnamed")"
+                hostDisplayName = "\(index). \(hostEntry.host)"
             } else {
                 // Search by host name
                 guard let foundEntry = entries.first(where: { $0.host == host }) else {
@@ -197,7 +147,7 @@ struct SSHConnectCommand: ParsableCommand {
                     throw ExitCode.failure
                 }
                 hostEntry = foundEntry
-                hostDisplayName = hostEntry.host ?? "unnamed"
+                hostDisplayName = hostEntry.host
             }
 
             if isDebugMode {
@@ -229,7 +179,7 @@ struct SSHConnectCommand: ParsableCommand {
             if let username = hostEntry.user, let hostname = hostEntry.hostname {
                 targetAddress = "\(username)@\(hostname)"
             } else {
-                targetAddress = hostEntry.host ?? host
+                targetAddress = hostEntry.host // Updated since host is now non-optional
             }
             argsArray.append(targetAddress)
 
@@ -257,7 +207,7 @@ struct SSHConnectCommand: ParsableCommand {
         print("System version: \(ProcessInfo.processInfo.operatingSystemVersionString)")
 
         print("\n===== Host Configuration Information =====")
-        print("Host: \(hostEntry.host ?? "unnamed")")
+        print("Host: \(hostEntry.host)")
         print("Hostname: \(hostEntry.hostname ?? "not specified")")
         print("User: \(hostEntry.user ?? "not specified")")
         print("Port: \(hostEntry.port ?? "not specified (default: 22)")")

CLI/Sources/ConfigForgeCLI/Models/SSHConfigEntry.swift

@@ -1,38 +1,83 @@
 import Foundation
 
 struct SSHConfigEntry {
-    var host: String?
-    var hostname: String?
-    var user: String?
-    var port: String?
-    var identityFile: String?
-    var forwardAgent: String?
-    var proxyCommand: String?
-    var serverAliveInterval: String?
-    var serverAliveCountMax: String?
-    var strictHostKeyChecking: String?
-    var userKnownHostsFile: String?
-    var connectTimeout: String?
-    var otherOptions: [String: String] = [:]
-    
-    init(host: String? = nil, hostname: String? = nil, user: String? = nil, 
-         port: String? = nil, identityFile: String? = nil, forwardAgent: String? = nil, 
-         proxyCommand: String? = nil, serverAliveInterval: String? = nil, 
-         serverAliveCountMax: String? = nil, strictHostKeyChecking: String? = nil, 
-         userKnownHostsFile: String? = nil, connectTimeout: String? = nil, 
-         otherOptions: [String: String] = [:]) {
+    let id: UUID
+    var host: String
+    var directives: [(key: String, value: String)] = []
+    
+    // Default initializer that generates a new UUID
+    init(host: String, directives: [(key: String, value: String)] = []) {
+        self.id = UUID()
+        self.host = host
+        self.directives = directives
+    }
+    
+    // Initializer that accepts a specific UUID (for updates)
+    init(id: UUID, host: String, directives: [(key: String, value: String)] = []) {
+        self.id = id
         self.host = host
-        self.hostname = hostname
-        self.user = user
-        self.port = port
-        self.identityFile = identityFile
-        self.forwardAgent = forwardAgent
-        self.proxyCommand = proxyCommand
-        self.serverAliveInterval = serverAliveInterval
-        self.serverAliveCountMax = serverAliveCountMax
-        self.strictHostKeyChecking = strictHostKeyChecking
-        self.userKnownHostsFile = userKnownHostsFile
-        self.connectTimeout = connectTimeout
-        self.otherOptions = otherOptions
+        self.directives = directives
+    }
+    
+    // Computed properties for backward compatibility and easy access
+    var hostname: String? {
+        directives.first { $0.key.lowercased() == "hostname" }?.value
+    }
+    
+    var user: String? {
+        directives.first { $0.key.lowercased() == "user" }?.value
+    }
+    
+    var port: String? {
+        directives.first { $0.key.lowercased() == "port" }?.value
+    }
+    
+    var identityFile: String? {
+        directives.first { $0.key.lowercased() == "identityfile" }?.value
+    }
+    
+    var forwardAgent: String? {
+        directives.first { $0.key.lowercased() == "forwardagent" }?.value
+    }
+    
+    var proxyCommand: String? {
+        directives.first { $0.key.lowercased() == "proxycommand" }?.value
+    }
+    
+    var serverAliveInterval: String? {
+        directives.first { $0.key.lowercased() == "serveraliveinterval" }?.value
+    }
+    
+    var serverAliveCountMax: String? {
+        directives.first { $0.key.lowercased() == "serveralivecountmax" }?.value
+    }
+    
+    var strictHostKeyChecking: String? {
+        directives.first { $0.key.lowercased() == "stricthostkeychecking" }?.value
+    }
+    
+    var userKnownHostsFile: String? {
+        directives.first { $0.key.lowercased() == "userknownhostsfile" }?.value
+    }
+    
+    var connectTimeout: String? {
+        directives.first { $0.key.lowercased() == "connecttimeout" }?.value
+    }
+    
+    // Get other options that are not in the standard properties
+    var otherOptions: [String: String] {
+        let standardKeys = Set([
+            "hostname", "user", "port", "identityfile", "forwardagent", 
+            "proxycommand", "serveraliveinterval", "serveralivecountmax",
+            "stricthostkeychecking", "userknownhostsfile", "connecttimeout"
+        ])
+        
+        var others: [String: String] = [:]
+        for directive in directives {
+            if !standardKeys.contains(directive.key.lowercased()) {
+                others[directive.key] = directive.value
+            }
+        }
+        return others
     }
 } 

CLI/Sources/ConfigForgeCLI/Services/CLISSHConfigFileManager.swift

@@ -26,11 +26,34 @@ class CLISSHConfigFileManager {
 class CLISSHConfigParser {
     func parseConfig(content: String) throws -> [SSHConfigEntry] {
         var entries: [SSHConfigEntry] = []
-        var currentEntry: SSHConfigEntry?
+        var currentHost: String?
+        var currentDirectives: [(key: String, value: String)] = []
+        var inMultilineValue = false
+        var multilineKey: String?
 
         let lines = content.components(separatedBy: .newlines)
 
-        for line in lines {
+        for lineIndex in 0..<lines.count {
+            let line = lines[lineIndex]
+            
+            // Handle multiline values (lines starting with whitespace)
+            if line.first?.isWhitespace == true && inMultilineValue && multilineKey != nil {
+                if var lastDirective = currentDirectives.popLast(), lastDirective.key == multilineKey {
+                    var lineContent = line.trimmingCharacters(in: .whitespaces)
+                    if lineContent.hasSuffix("\\") {
+                        lineContent = String(lineContent.dropLast())
+                        lastDirective.value += " " + lineContent
+                        currentDirectives.append(lastDirective)
+                    } else {
+                        lastDirective.value += " " + lineContent
+                        currentDirectives.append(lastDirective)
+                        inMultilineValue = false
+                        multilineKey = nil
+                    }
+                }
+                continue
+            }
+            
             let trimmedLine = line.trimmingCharacters(in: .whitespaces)
 
             // Skip comments and empty lines
@@ -42,56 +65,58 @@ class CLISSHConfigParser {
             let components = trimmedLine.components(separatedBy: .whitespaces)
             guard components.count >= 2 else { continue }
 
-            let key = components[0].lowercased()
+            let key = components[0]
             let value = components[1...].joined(separator: " ")
+            let keyword = key.lowercased()
 
             // New Host entry starts
-            if key == "host" {
+            if keyword == "host" {
                 // Save the previous entry if exists
-                if let entry = currentEntry {
-                    entries.append(entry)
+                if let host = currentHost, !host.isEmpty {
+                    entries.append(SSHConfigEntry(host: host, directives: currentDirectives))
                 }
 
                 // Start a new entry
-                currentEntry = SSHConfigEntry(host: value)
-            } else if var entry = currentEntry {
-                // Add the option to the current entry
-                switch key {
-                case "hostname":
-                    entry.hostname = value
-                case "user":
-                    entry.user = value
-                case "port":
-                    entry.port = value
-                case "identityfile":
-                    entry.identityFile = value
-                case "forwardagent":
-                    entry.forwardAgent = value
-                case "proxycommand":
-                    entry.proxyCommand = value
-                case "serveraliveinterval":
-                    entry.serverAliveInterval = value
-                case "serveralivecountmax":
-                    entry.serverAliveCountMax = value
-                case "stricthostkeychecking":
-                    entry.strictHostKeyChecking = value
-                case "userknownhostsfile":
-                    entry.userKnownHostsFile = value
-                case "connecttimeout":
-                    entry.connectTimeout = value
-                default:
-                    entry.otherOptions[key] = value
-                }
+                currentHost = value
+                currentDirectives = []
+            } else if currentHost != nil {
+                // Format the key properly
+                let formattedKey = formatPropertyKey(keyword)
 
-                currentEntry = entry
+                // Handle multiline values
+                if value.hasSuffix("\\") {
+                    inMultilineValue = true
+                    multilineKey = formattedKey
+                    currentDirectives.append((key: formattedKey, value: String(value.dropLast())))
+                } else {
+                    currentDirectives.append((key: formattedKey, value: value))
+                }
             }
         }
 
         // Add the last entry
-        if let entry = currentEntry {
-            entries.append(entry)
+        if let host = currentHost, !host.isEmpty {
+            entries.append(SSHConfigEntry(host: host, directives: currentDirectives))
         }
 
         return entries
     }
+    
+    private func formatPropertyKey(_ key: String) -> String {
+        let propertyMappings: [String: String] = [
+            "hostname": "HostName",
+            "user": "User",
+            "port": "Port",
+            "identityfile": "IdentityFile",
+            "forwardagent": "ForwardAgent",
+            "proxycommand": "ProxyCommand",
+            "serveraliveinterval": "ServerAliveInterval",
+            "serveralivecountmax": "ServerAliveCountMax",
+            "stricthostkeychecking": "StrictHostKeyChecking",
+            "userknownhostsfile": "UserKnownHostsFile",
+            "connecttimeout": "ConnectTimeout"
+        ]
+        
+        return propertyMappings[key] ?? key.capitalized
+    }
 }