Adding colima support to existing docker runtime searches

- Respects the default colima socket location
  - TOOLHIVE_COLIMA_SOCKET=.colima/default/docker.sock
  - This is documented here: https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#v040-or-newer
- Adds test coverage for new colima functionality

Author: JesseObrien

pkg/container/docker/sdk/client_unix.go

@@ -53,6 +53,15 @@ func findPlatformContainerSocket(rt runtime.Type) (string, runtime.Type, error)
 		return customSocketPath, runtime.TypePodman, nil
 	}
 
+	if customSocketPath := os.Getenv(ColimaSocketEnv); customSocketPath != "" {
+		logger.Debugf("Using Colima socket from env: %s", customSocketPath)
+		// validate the socket path
+		if _, err := os.Stat(customSocketPath); err != nil {
+			return "", runtime.TypeColima, fmt.Errorf("invalid Colima socket path: %w", err)
+		}
+		return customSocketPath, runtime.TypeColima, nil
+	}
+
 	if customSocketPath := os.Getenv(DockerSocketEnv); customSocketPath != "" {
 		logger.Debugf("Using Docker socket from env: %s", customSocketPath)
 		// validate the socket path
@@ -78,6 +87,13 @@ func findPlatformContainerSocket(rt runtime.Type) (string, runtime.Type, error)
 		}
 	}
 
+	if rt == runtime.TypeColima {
+		socketPath, err := findColimaSocket()
+		if err == nil {
+			return socketPath, runtime.TypeColima, nil
+		}
+	}
+
 	if rt == runtime.TypeDocker {
 		socketPath, err := findDockerSocket()
 		if err == nil {
@@ -135,6 +151,24 @@ func findPodmanSocket() (string, error) {
 	return "", fmt.Errorf("podman socket not found in standard locations")
 }
 
+// findColimaSocket attempts to locate a Colima socket
+func findColimaSocket() (string, error) {
+	// Check user-specific location for Colima
+	if home := os.Getenv("HOME"); home != "" {
+		colimaSocketPath := filepath.Join(home, ColimaSocketPath)
+		_, err := os.Stat(colimaSocketPath)
+
+		if err == nil {
+			logger.Debugf("Found Colima socket at %s", colimaSocketPath)
+			return colimaSocketPath, nil
+		}
+
+		logger.Debugf("Failed to check Colima socket at %s: %v", colimaSocketPath, err)
+	}
+
+	return "", fmt.Errorf("colima socket not found in standard locations")
+}
+
 // findDockerSocket attempts to locate a Docker socket
 func findDockerSocket() (string, error) {
 	// Try Docker socket as fallback

pkg/container/docker/sdk/client_unix_test.go

@@ -0,0 +1,62 @@
+//go:build !windows
+// +build !windows
+
+package sdk
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/stacklok/toolhive/pkg/container/runtime"
+	"github.com/stacklok/toolhive/pkg/logger"
+)
+
+func init() {
+	// Initialize the logger for tests
+	logger.Initialize()
+}
+
+func TestColimaRuntimeTypeSupport(t *testing.T) {
+	t.Parallel()
+
+	// Test that Colima is included in supported socket paths
+	found := false
+	for _, rt := range supportedSocketPaths {
+		if rt == runtime.TypeColima {
+			found = true
+			break
+		}
+	}
+
+	require.True(t, found, "TypeColima should be included in supportedSocketPaths")
+}
+
+func TestColimaConstants(t *testing.T) {
+	t.Parallel()
+
+	// Test that Colima constants are properly defined
+	assert.Equal(t, "TOOLHIVE_COLIMA_SOCKET", ColimaSocketEnv)
+	assert.Equal(t, ".colima/default/docker.sock", ColimaSocketPath)
+	assert.Equal(t, runtime.Type("colima"), runtime.TypeColima)
+}
+
+func TestNewDockerClientWithColima(t *testing.T) {
+	t.Parallel()
+
+	// This test verifies that the NewDockerClient function can handle
+	// the Colima runtime type in the supportedSocketPaths without errors
+	// Note: This test won't actually connect since no container runtime is available
+	// but it verifies the code paths don't panic and handle the new runtime type
+
+	ctx := context.Background()
+	_, _, _, err := NewDockerClient(ctx)
+
+	// We expect an error since no container runtime is available in the test environment
+	// but we're testing that the function doesn't panic or have compile errors
+	// with the new Colima support
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "no supported container runtime")
+}

pkg/container/docker/sdk/client_windows.go

@@ -71,6 +71,19 @@ func findPlatformContainerSocket(rt runtime.Type) (string, runtime.Type, error)
 		return customPipePath, runtime.TypePodman, nil
 	}
 
+	if customPipePath := os.Getenv(ColimaSocketEnv); customPipePath != "" {
+		logger.Debugf("Using Colima pipe from env: %s", customPipePath)
+		// Validate the pipe path exists with timeout
+		ctx, cancel := context.WithTimeout(context.Background(), pipeConnectionTimeout)
+		defer cancel()
+		conn, err := winio.DialPipeContext(ctx, customPipePath)
+		if err != nil {
+			return "", runtime.TypeColima, fmt.Errorf("invalid Colima pipe path: %w", err)
+		}
+		conn.Close()
+		return customPipePath, runtime.TypeColima, nil
+	}
+
 	if customPipePath := os.Getenv(DockerSocketEnv); customPipePath != "" {
 		logger.Debugf("Using Docker pipe from env: %s", customPipePath)
 		// Validate the pipe path exists with timeout
@@ -97,6 +110,20 @@ func findPlatformContainerSocket(rt runtime.Type) (string, runtime.Type, error)
 		logger.Debugf("Failed to connect to Podman pipe at %s: %v", PodmanDesktopWindowsPipePath, err)
 	}
 
+	if rt == runtime.TypeColima {
+		// On Windows, Colima would typically use Docker Desktop's socket if available
+		// Try Docker named pipe as fallback for Colima
+		ctx, cancel := context.WithTimeout(context.Background(), pipeConnectionTimeout)
+		defer cancel()
+		conn, err := winio.DialPipeContext(ctx, DockerDesktopWindowsPipePath)
+		if err == nil {
+			logger.Debugf("Found Colima (Docker) pipe at %s", DockerDesktopWindowsPipePath)
+			conn.Close()
+			return DockerDesktopWindowsPipePath, runtime.TypeColima, nil
+		}
+		logger.Debugf("Failed to connect to Colima (Docker) pipe at %s: %v", DockerDesktopWindowsPipePath, err)
+	}
+
 	if rt == runtime.TypeDocker {
 		// Try Docker named pipe with timeout
 		ctx, cancel := context.WithTimeout(context.Background(), pipeConnectionTimeout)

pkg/container/docker/sdk/client_windows_test.go

@@ -0,0 +1,62 @@
+//go:build windows
+// +build windows
+
+package sdk
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/stacklok/toolhive/pkg/container/runtime"
+	"github.com/stacklok/toolhive/pkg/logger"
+)
+
+func init() {
+	// Initialize the logger for tests
+	logger.Initialize()
+}
+
+func TestColimaRuntimeTypeSupportWindows(t *testing.T) {
+	t.Parallel()
+
+	// Test that Colima is included in supported socket paths
+	found := false
+	for _, rt := range supportedSocketPaths {
+		if rt == runtime.TypeColima {
+			found = true
+			break
+		}
+	}
+
+	require.True(t, found, "TypeColima should be included in supportedSocketPaths")
+}
+
+func TestColimaConstantsWindows(t *testing.T) {
+	t.Parallel()
+
+	// Test that Colima constants are properly defined
+	assert.Equal(t, "TOOLHIVE_COLIMA_SOCKET", ColimaSocketEnv)
+	assert.Equal(t, ".colima/default/docker.sock", ColimaSocketPath)
+	assert.Equal(t, runtime.Type("colima"), runtime.TypeColima)
+}
+
+func TestNewDockerClientWithColimaWindows(t *testing.T) {
+	t.Parallel()
+
+	// This test verifies that the NewDockerClient function can handle
+	// the Colima runtime type in the supportedSocketPaths without errors on Windows
+	// Note: This test won't actually connect since no container runtime is available
+	// but it verifies the code paths don't panic and handle the new runtime type
+
+	ctx := context.Background()
+	_, _, _, err := NewDockerClient(ctx)
+
+	// We expect an error since no container runtime is available in the test environment
+	// but we're testing that the function doesn't panic or have compile errors
+	// with the new Colima support
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "no supported container runtime")
+}

pkg/container/docker/sdk/factory.go

@@ -34,6 +34,8 @@ const (
 	PodmanXDGRuntimeSocketPath = "podman/podman.sock"
 	// DockerSocketPath is the default Docker socket path
 	DockerSocketPath = "/var/run/docker.sock"
+	// ColimaSocketPath is the default Colima socket path
+	ColimaSocketPath = ".colima/default/docker.sock"
 	// DockerDesktopMacSocketPath is the Docker Desktop socket path on macOS
 	DockerDesktopMacSocketPath = ".docker/run/docker.sock"
 	// RancherDesktopMacSocketPath is the Docker socket path for Rancher Desktop on macOS

pkg/container/runtime/types.go

@@ -185,6 +185,8 @@ const (
 	TypePodman Type = "podman"
 	// TypeDocker represents the Docker runtime
 	TypeDocker Type = "docker"
+	// TypeColima represents the Colima runtime
+	TypeColima Type = "colima"
 	// TypeKubernetes represents the Kubernetes runtime
 	TypeKubernetes Type = "kubernetes"
 	// TypeColima represents the Colima runtime

pkg/container/runtime/types_test.go

@@ -0,0 +1,59 @@
+package runtime
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRuntimeTypes(t *testing.T) {
+	t.Parallel()
+
+	// Test that all runtime types are properly defined
+	tests := []struct {
+		name          string
+		runtimeType   Type
+		expectedValue string
+	}{
+		{
+			name:          "TypePodman",
+			runtimeType:   TypePodman,
+			expectedValue: "podman",
+		},
+		{
+			name:          "TypeDocker",
+			runtimeType:   TypeDocker,
+			expectedValue: "docker",
+		},
+		{
+			name:          "TypeColima",
+			runtimeType:   TypeColima,
+			expectedValue: "colima",
+		},
+		{
+			name:          "TypeKubernetes",
+			runtimeType:   TypeKubernetes,
+			expectedValue: "kubernetes",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, tt.expectedValue, string(tt.runtimeType))
+		})
+	}
+}
+
+func TestColimaRuntimeTypeExists(t *testing.T) {
+	t.Parallel()
+
+	// Ensure TypeColima constant exists and has the correct value
+	assert.Equal(t, Type("colima"), TypeColima)
+
+	// Verify it's different from other runtime types
+	assert.NotEqual(t, TypeColima, TypeDocker)
+	assert.NotEqual(t, TypeColima, TypePodman)
+	assert.NotEqual(t, TypeColima, TypeKubernetes)
+}