docker.go

package main

import (
	"context"
	"fmt"
	"os/exec"
	"strings"
	"time"
)

// DockerExecutor runs commands inside a Docker container.
type DockerExecutor struct {
	container string
	shell     string
	owned     bool // true if we created the container (should stop on Close)
}

// NewDockerExecutor connects to an existing container or creates one from an image.
// If container is set, exec into that container.
// If image is set, create a new container from the image.
func NewDockerExecutor(container, image, shell string) (*DockerExecutor, error) {
	if shell == "" {
		shell = "sh"
	}

	if container != "" {
		// Verify container is running
		out, err := exec.Command("docker", "inspect", "-f", "{{.State.Running}}", container).CombinedOutput()
		if err != nil {
			return nil, fmt.Errorf("container %q not found or not accessible: %s", container, strings.TrimSpace(string(out)))
		}
		if strings.TrimSpace(string(out)) != "true" {
			return nil, fmt.Errorf("container %q is not running", container)
		}
		return &DockerExecutor{container: container, shell: shell, owned: false}, nil
	}

	if image != "" {
		// Create a long-running container from the image
		out, err := exec.Command("docker", "run", "-d", "--rm", image, "sleep", "infinity").CombinedOutput()
		if err != nil {
			return nil, fmt.Errorf("failed to create container from image %q: %s", image, strings.TrimSpace(string(out)))
		}
		containerID := strings.TrimSpace(string(out))
		return &DockerExecutor{container: containerID, shell: shell, owned: true}, nil
	}

	return nil, fmt.Errorf("either container or image must be set")
}

func (e *DockerExecutor) Exec(command string, timeout int) (string, error) {
	var ctx context.Context
	var cancel context.CancelFunc

	if timeout > 0 {
		ctx, cancel = context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
		defer cancel()
	} else {
		ctx = context.Background()
	}

	cmd := exec.CommandContext(ctx, "docker", "exec", e.container, e.shell, "-c", command)
	output, err := cmd.CombinedOutput()

	if ctx.Err() == context.DeadlineExceeded {
		return string(output), fmt.Errorf("command timed out after %d seconds", timeout)
	}
	if err != nil {
		return string(output) + "\nError: " + err.Error(), nil
	}
	return string(output), nil
}

func (e *DockerExecutor) Close() error {
	if e.owned && e.container != "" {
		exec.Command("docker", "stop", e.container).Run()
	}
	return nil
}