Hotfix/certs

.claude/settings.local.json

@@ -12,7 +12,12 @@
       "Bash(done)",
       "Bash(for node in idp-control-plane idp-worker idp-worker2)",
       "Bash(kubectl --context kind-idp get pods:*)",
-      "Bash(kubectl --context kind-idp delete pod:*)"
+      "Bash(kubectl --context kind-idp delete pod:*)",
+      "Bash(grep:*)",
+      "WebFetch(domain:github.com)",
+      "Bash(dotnet build:*)",
+      "Bash(dotnet test:*)",
+      "Bash(test:*)"
     ]
   }
 }

cli/src/Vdk/Commands/UpdateClustersCommand.cs

@@ -420,7 +420,7 @@ private async Task RolloutRestartDeployment(IKubernetesClient client, V1Deployme
 
     /// <summary>
     /// Checks if a certificate path exists as a directory instead of a file
-    /// and removes it. On some systems (especially Mac), Docker may incorrectly
+    /// and removes it. On some systems (especially Mac and WSL2), Docker may incorrectly
     /// create directories when mounting paths that don't exist.
     /// </summary>
     private void FixCertificatePathIfDirectory(string path, bool verbose)
@@ -436,10 +436,73 @@ private void FixCertificatePathIfDirectory(string path, bool verbose)
                     _console.WriteLine($"[DEBUG] Successfully removed directory '{path}'");
                 }
             }
-            catch (Exception ex)
+            catch (Exception)
             {
-                _console.WriteError($"Failed to remove directory '{path}': {ex.Message}");
+                // On WSL2/Linux, directories created by Docker may have root ownership.
+                // Fall back to shell command with elevated permissions.
+                if (TryRemoveDirectoryWithShell(path, verbose))
+                {
+                    if (verbose)
+                    {
+                        _console.WriteLine($"[DEBUG] Successfully removed directory '{path}' using shell command");
+                    }
+                }
+                else
+                {
+                    _console.WriteError($"Failed to remove directory '{path}'. Try running: sudo rm -rf \"{path}\"");
+                }
             }
         }
     }
+
+    /// <summary>
+    /// Attempts to remove a directory using shell commands, which may succeed
+    /// when .NET Directory.Delete fails due to permission issues.
+    /// </summary>
+    private bool TryRemoveDirectoryWithShell(string path, bool verbose)
+    {
+        try
+        {
+            var isWindows = System.OperatingSystem.IsWindows();
+            var startInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = isWindows ? "cmd.exe" : "/bin/sh",
+                Arguments = isWindows
+                    ? $"/c rmdir /s /q \"{path}\""
+                    : $"-c \"rm -rf '{path}'\"",
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            };
+
+            using var process = System.Diagnostics.Process.Start(startInfo);
+            process?.WaitForExit(5000);
+
+            // Check if directory was actually removed
+            if (!_fileSystem.Directory.Exists(path))
+            {
+                return true;
+            }
+
+            // If still exists, try with sudo on Linux/Mac
+            if (!isWindows)
+            {
+                if (verbose)
+                {
+                    _console.WriteLine($"[DEBUG] Attempting sudo rm -rf for '{path}'");
+                }
+                startInfo.Arguments = $"-c \"sudo rm -rf '{path}'\"";
+                using var sudoProcess = System.Diagnostics.Process.Start(startInfo);
+                sudoProcess?.WaitForExit(10000);
+                return !_fileSystem.Directory.Exists(path);
+            }
+
+            return false;
+        }
+        catch
+        {
+            return false;
+        }
+    }
 }

cli/src/Vdk/Services/DockerHubClient.cs

@@ -15,6 +15,67 @@ public void CreateRegistry()
         var configFile = new FileInfo(Path.Combine("ConfigMounts", "zot-config.json"));
         var imagesDir = new DirectoryInfo("images");
 
+        // Ensure ConfigMounts directory exists
+        var configMountsDir = configFile.Directory;
+        if (configMountsDir != null && !configMountsDir.Exists)
+        {
+            configMountsDir.Create();
+        }
+
+        // Fix: Check if config file was incorrectly created as a directory by Docker
+        if (Directory.Exists(configFile.FullName))
+        {
+            console.WriteLine($"Config path '{configFile.FullName}' exists as a directory instead of a file. Removing...");
+            Directory.Delete(configFile.FullName, recursive: true);
+        }
+
+        // Ensure config file exists - try to copy from app directory or create default
+        if (!configFile.Exists)
+        {
+            // Try to find config in application base directory
+            var appBaseConfig = Path.Combine(AppContext.BaseDirectory, "ConfigMounts", "zot-config.json");
+            if (File.Exists(appBaseConfig))
+            {
+                console.WriteLine($"Copying zot config from {appBaseConfig}");
+                File.Copy(appBaseConfig, configFile.FullName);
+            }
+            else
+            {
+                // Create default config
+                console.WriteLine("Creating default zot-config.json");
+                var defaultConfig = """
+                    {
+                      "distSpecVersion": "1.1.0",
+                      "storage": {
+                        "rootDirectory": "/var/lib/registry",
+                        "gc": true,
+                        "gcDelay": "1h",
+                        "gcInterval": "24h"
+                      },
+                      "http": {
+                        "address": "0.0.0.0",
+                        "port": "5000"
+                      },
+                      "log": {
+                        "level": "info"
+                      },
+                      "extensions": {
+                        "ui": {
+                          "enable": true
+                        },
+                        "search": {
+                          "enable": true,
+                          "cve": {
+                            "updateInterval": "24h"
+                          }
+                        }
+                      }
+                    }
+                    """;
+                File.WriteAllText(configFile.FullName, defaultConfig);
+            }
+        }
+
         // Ensure images directory exists
         if (!imagesDir.Exists)
         {

cli/src/Vdk/Services/FallbackDockerEngine.cs

@@ -25,6 +25,16 @@ internal static bool RunProcess(string fileName, string arguments, out string st
 
         public bool Run(string image, string name, PortMapping[]? ports, Dictionary<string, string>? envs, FileMapping[]? volumes, string[]? commands, string? network = null)
         {
+            // Validate and fix volume mount sources before creating container
+            // This prevents Docker from creating directories when files are expected
+            if (volumes != null)
+            {
+                foreach (var volume in volumes)
+                {
+                    EnsureVolumeMountSource(volume.Source, volume.Destination);
+                }
+            }
+
             var args = $"run -d --name {name}";
             if (network != null)
                 args += $" --network {network}";
@@ -53,6 +63,54 @@ public bool Run(string image, string name, PortMapping[]? ports, Dictionary<stri
             return RunProcess("docker", args, out _, out _);
         }
 
+        /// <summary>
+        /// Ensures that a volume mount source path exists correctly.
+        /// Fixes the common Docker issue where mounting a non-existent file creates a directory instead.
+        /// </summary>
+        private void EnsureVolumeMountSource(string sourcePath, string destinationPath)
+        {
+            // Determine if destination looks like a file (has extension) or directory
+            bool isFilePath = Path.HasExtension(destinationPath) && !destinationPath.EndsWith('/') && !destinationPath.EndsWith('\\');
+
+            // Check if path was incorrectly created as a directory when it should be a file
+            if (isFilePath && Directory.Exists(sourcePath))
+            {
+                Console.WriteLine($"Mount path '{sourcePath}' exists as a directory instead of a file. Removing...");
+                try
+                {
+                    Directory.Delete(sourcePath, recursive: true);
+                }
+                catch (Exception ex)
+                {
+                    throw new InvalidOperationException(
+                        $"Failed to remove directory '{sourcePath}': {ex.Message}",
+                        ex);
+                }
+            }
+
+            // Ensure parent directory exists
+            var parentDir = Path.GetDirectoryName(sourcePath);
+            if (!string.IsNullOrEmpty(parentDir) && !Directory.Exists(parentDir))
+            {
+                Directory.CreateDirectory(parentDir);
+            }
+
+            // For file paths, ensure the file exists
+            if (isFilePath && !File.Exists(sourcePath))
+            {
+                throw new FileNotFoundException(
+                    $"Mount source file does not exist: '{sourcePath}'. " +
+                    $"Please ensure the required config file exists before running this command.",
+                    sourcePath);
+            }
+
+            // For directory paths, ensure directory exists
+            if (!isFilePath && !Directory.Exists(sourcePath))
+            {
+                Directory.CreateDirectory(sourcePath);
+            }
+        }
+
         public bool Exists(string name, bool checkRunning = true)
         {
             var filter = checkRunning ? "--filter \"status=running\"" : "";

cli/src/Vdk/Services/LocalDockerClient.cs

@@ -14,6 +14,16 @@ public LocalDockerClient(Docker.DotNet.IDockerClient dockerClient)
 
     public bool Run(string image, string name, PortMapping[]? ports, Dictionary<string, string>? envs, FileMapping[]? volumes, string[]? commands, string? network = null)
     {
+        // Validate and fix volume mount sources before creating container
+        // This prevents Docker from creating directories when files are expected
+        if (volumes != null)
+        {
+            foreach (var volume in volumes)
+            {
+                EnsureVolumeMountSource(volume.Source, volume.Destination);
+            }
+        }
+
         _dockerClient.Images.CreateImageAsync(
           new ImagesCreateParameters
           {
@@ -160,4 +170,52 @@ public bool CanConnect()
             return false;
         }
     }
+
+    /// <summary>
+    /// Ensures that a volume mount source path exists correctly.
+    /// Fixes the common Docker issue where mounting a non-existent file creates a directory instead.
+    /// </summary>
+    private void EnsureVolumeMountSource(string sourcePath, string destinationPath)
+    {
+        // Determine if destination looks like a file (has extension) or directory
+        bool isFilePath = Path.HasExtension(destinationPath) && !destinationPath.EndsWith('/') && !destinationPath.EndsWith('\\');
+
+        // Check if path was incorrectly created as a directory when it should be a file
+        if (isFilePath && Directory.Exists(sourcePath))
+        {
+            Console.WriteLine($"Certificate path '{sourcePath}' exists as a directory instead of a file. Removing...");
+            try
+            {
+                Directory.Delete(sourcePath, recursive: true);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to remove directory '{sourcePath}': {ex.Message}",
+                    ex);
+            }
+        }
+
+        // Ensure parent directory exists
+        var parentDir = Path.GetDirectoryName(sourcePath);
+        if (!string.IsNullOrEmpty(parentDir) && !Directory.Exists(parentDir))
+        {
+            Directory.CreateDirectory(parentDir);
+        }
+
+        // For file paths, ensure the file exists
+        if (isFilePath && !File.Exists(sourcePath))
+        {
+            throw new FileNotFoundException(
+                $"Mount source file does not exist: '{sourcePath}'. " +
+                $"Please ensure the required config file exists before running this command.",
+                sourcePath);
+        }
+
+        // For directory paths, ensure directory exists
+        if (!isFilePath && !Directory.Exists(sourcePath))
+        {
+            Directory.CreateDirectory(sourcePath);
+        }
+    }
 }