fix(docker): restart and wait for container readiness before exec (#688)

When Podman on Windows encounters instability, a container can exit
during or after the first exec. Previously, the injection retry loop
would retry docker exec 30 times against a dead container without
ever attempting to restart it.

Add WaitContainerRunning to DockerHelper that polls docker inspect
until the container reports running status, following the same
wait.PollUntilContextTimeout pattern used by the Kubernetes driver.
CommandDevContainer now detects stopped containers, restarts them,
and waits for readiness before proceeding with exec.

The injection retry predicate in inject.go now fails fast on terminal
container states (dead/removing) using a sentinel error instead of
burning through all 30 retries.

Author: skevetter

pkg/agent/inject.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/skevetter/devpod/pkg/config"
+	"github.com/skevetter/devpod/pkg/docker"
 	"github.com/skevetter/devpod/pkg/inject"
 	"github.com/skevetter/devpod/pkg/shell"
 	"github.com/skevetter/devpod/pkg/version"
@@ -193,6 +194,10 @@ func InjectAgent(opts *InjectOptions) error {
 		if opts.Ctx.Err() != nil {
 			return false
 		}
+		if errors.Is(err, docker.ErrContainerTerminal) {
+			opts.Log.Errorf("container entered a terminal state, not retrying: %v", err)
+			return false
+		}
 		opts.Log.Debugf("retrying injection: %v", err)
 		return true
 	}, func() error {

pkg/docker/helper.go

@@ -10,12 +10,14 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"time"
 
 	"github.com/skevetter/devpod/pkg/command"
 	"github.com/skevetter/devpod/pkg/devcontainer/config"
 	"github.com/skevetter/devpod/pkg/image"
 	"github.com/skevetter/log"
 	"github.com/skevetter/log/scanner"
+	"k8s.io/apimachinery/pkg/util/wait"
 )
 
 // DockerBuilder represents the Docker builder types.
@@ -204,6 +206,62 @@ func (r *DockerHelper) StartContainer(ctx context.Context, containerId string) e
 	return nil
 }
 
+// ErrContainerTerminal indicates a container entered an unrecoverable state
+// (e.g. "dead" or "removing") and cannot be restarted.
+var ErrContainerTerminal = errors.New("container in terminal state")
+
+const (
+	containerRunningPollInterval = 500 * time.Millisecond
+	containerRunningTimeout      = 30 * time.Second
+)
+
+// WaitContainerRunning polls docker inspect until the container reports
+// status "running" or the context/timeout expires. It does not start
+// the container — the caller is responsible for that.
+func (r *DockerHelper) WaitContainerRunning(ctx context.Context, containerID string) error {
+	var lastErr error
+	pollErr := wait.PollUntilContextTimeout(
+		ctx, containerRunningPollInterval, containerRunningTimeout, true,
+		func(ctx context.Context) (bool, error) {
+			details, err := r.InspectContainers(ctx, []string{containerID})
+			if err != nil {
+				lastErr = err
+				r.Log.Debugf("WaitContainerRunning: inspect error (will retry): %v", err)
+				return false, nil
+			}
+			if len(details) == 0 {
+				return false, fmt.Errorf(
+					"container %s disappeared while waiting for it to start",
+					containerID,
+				)
+			}
+			lastErr = nil
+			status := strings.ToLower(details[0].State.Status)
+			if status == "running" {
+				return true, nil
+			}
+			if status == "removing" || status == "dead" {
+				return false, fmt.Errorf(
+					"%w: container %s is %q",
+					ErrContainerTerminal,
+					containerID,
+					status,
+				)
+			}
+			r.Log.Debugf(
+				"WaitContainerRunning: container %s status=%s, waiting...",
+				containerID,
+				status,
+			)
+			return false, nil
+		},
+	)
+	if pollErr != nil && lastErr != nil {
+		return fmt.Errorf("%w (last inspect error: %v)", pollErr, lastErr)
+	}
+	return pollErr
+}
+
 func (r *DockerHelper) GetImageTag(ctx context.Context, imageID string) (string, error) {
 	args := []string{
 		"inspect",

pkg/driver/docker/docker.go

@@ -91,6 +91,29 @@ func (d *dockerDriver) CommandDevContainer(
 		return fmt.Errorf("container not found")
 	}
 
+	status := strings.ToLower(container.State.Status)
+	if status == "dead" || status == "removing" {
+		return fmt.Errorf(
+			"%w: container %s is %q",
+			docker.ErrContainerTerminal,
+			container.ID,
+			status,
+		)
+	}
+	if status != "running" {
+		d.Log.Infof(
+			"container %s is not running (status=%s), restarting",
+			container.ID, status,
+		)
+		if err := d.Docker.StartContainer(ctx, container.ID); err != nil {
+			return fmt.Errorf("restart container: %w", err)
+		}
+		if err := d.Docker.WaitContainerRunning(ctx, container.ID); err != nil {
+			return fmt.Errorf("wait for container to be running: %w", err)
+		}
+		d.Log.Infof("container %s is now running", container.ID)
+	}
+
 	args := []string{"exec"}
 	if stdin != nil {
 		args = append(args, "-i")