feat(delivery): add KubernetesDelivery strategy for K8s agent binary injection

.github/workflows/pr-ci.yml

@@ -216,6 +216,12 @@ jobs:
             install-kind: false
             requires-secret: false
 
+          - label: delivery
+            runner: ubuntu-latest
+            free-disk-space: false
+            install-kind: false
+            requires-secret: false
+
           - label: exec
             runner: ubuntu-latest
             free-disk-space: false

e2e/e2e_suite_test.go

@@ -10,6 +10,7 @@ import (
 	// Register tests.
 	_ "github.com/devsy-org/devsy/e2e/tests/build"
 	_ "github.com/devsy-org/devsy/e2e/tests/context"
+	_ "github.com/devsy-org/devsy/e2e/tests/delivery"
 	_ "github.com/devsy-org/devsy/e2e/tests/dockerinstall"
 	_ "github.com/devsy-org/devsy/e2e/tests/down"
 	_ "github.com/devsy-org/devsy/e2e/tests/exec"

e2e/tests/delivery/delivery.go

@@ -0,0 +1,120 @@
+package delivery
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/devsy-org/devsy/e2e/framework"
+	"github.com/devsy-org/devsy/pkg/agent/delivery"
+	"github.com/devsy-org/devsy/pkg/devcontainer/config"
+	"github.com/devsy-org/devsy/pkg/driver"
+	"github.com/onsi/ginkgo/v2"
+	"github.com/onsi/gomega"
+)
+
+var _ = ginkgo.Describe("agent delivery", ginkgo.Label("delivery"), func() {
+	ginkgo.Context("LocalDockerDelivery", func() {
+		ginkgo.It("should create volume, populate binary, and mount into RunOptions",
+			ginkgo.SpecTimeout(framework.TimeoutShort()),
+			func(ctx context.Context) {
+				d := &delivery.LocalDockerDelivery{DockerCommand: "docker"}
+				workspaceID := "e2e-delivery-local"
+
+				runOpts := &driver.RunOptions{
+					Mounts: []*config.Mount{},
+					Env:    map[string]string{},
+				}
+
+				binaryPath := findTestBinary()
+
+				err := d.DeliverPreStart(ctx, delivery.PreStartOptions{
+					WorkspaceID:  workspaceID,
+					RunOptions:   runOpts,
+					BinarySource: binarySourceFromPath(binaryPath),
+					Arch:         "amd64",
+				})
+				framework.ExpectNoError(err)
+				ginkgo.DeferCleanup(func() {
+					_ = d.Cleanup(context.Background(), workspaceID)
+				})
+
+				gomega.Expect(runOpts.Mounts).To(gomega.HaveLen(1))
+				expectedVolume := "devsy-agent-" + workspaceID
+				gomega.Expect(runOpts.Mounts[0].Source).To(gomega.Equal(expectedVolume))
+				gomega.Expect(runOpts.Mounts[0].Type).To(gomega.Equal("volume"))
+
+				// Verify binary in volume via docker run
+				out, err := exec.CommandContext(ctx, "docker", "run", "--rm",
+					"-v", "devsy-agent-"+workspaceID+":/opt/devsy",
+					"busybox:latest", "test", "-x", "/opt/devsy/devsy",
+				).CombinedOutput()
+				framework.ExpectNoError(
+					err, "binary should be executable in volume: %s", string(out),
+				)
+			})
+	})
+
+	ginkgo.Context("RemoteDockerDelivery", func() {
+		ginkgo.It("should copy binary into running container via docker cp",
+			ginkgo.SpecTimeout(framework.TimeoutShort()),
+			func(ctx context.Context) {
+				containerName := "e2e-delivery-remote"
+
+				out, err := exec.CommandContext(ctx, "docker", "run", "-d",
+					"--name", containerName,
+					"busybox:latest", "sleep", "120",
+				).CombinedOutput()
+				framework.ExpectNoError(err, "failed to start test container: %s", string(out))
+				ginkgo.DeferCleanup(func() {
+					_ = exec.Command("docker", "rm", "-f", containerName).Run()
+				})
+
+				d := &delivery.RemoteDockerDelivery{
+					DockerCommand: "docker",
+					ContainerID:   containerName,
+				}
+
+				binaryPath := findTestBinary()
+
+				err = d.DeliverPostStart(ctx, delivery.PostStartOptions{
+					WorkspaceID:  "e2e-workspace",
+					BinarySource: binarySourceFromPath(binaryPath),
+					Arch:         "amd64",
+				})
+				framework.ExpectNoError(err)
+
+				// Verify binary exists and is executable
+				out, err = exec.CommandContext(ctx, "docker", "exec", containerName,
+					"test", "-x", "/usr/local/bin/devsy",
+				).CombinedOutput()
+				framework.ExpectNoError(err, "binary should be executable: %s", string(out))
+			})
+	})
+})
+
+func binarySourceFromPath(path string) delivery.BinarySourceFunc {
+	return func(_ context.Context, _ string) (io.ReadCloser, error) {
+		// #nosec G304 -- test helper with controlled paths
+		return os.Open(path)
+	}
+}
+
+func findTestBinary() string {
+	candidates := []string{"/bin/sh", "/bin/busybox"}
+	for _, c := range candidates {
+		if _, err := os.Stat(c); err == nil {
+			return c
+		}
+	}
+
+	binDir, _ := os.Getwd()
+	devsy := filepath.Join(binDir, "bin", "devsy-linux-amd64")
+	if _, err := os.Stat(devsy); err == nil {
+		return devsy
+	}
+
+	return "/bin/sh"
+}

pkg/agent/delivery/factory.go

@@ -16,6 +16,7 @@ type FactoryOptions struct {
 	WorkspaceID     string
 	DockerCommand   string
 	DockerEnv       []string
+	HelperImage     string
 	IsRemoteDocker  bool
 	ContainerID     string
 	ExecFunc        inject.ExecFunc
@@ -32,6 +33,13 @@ func NewAgentDelivery(opts FactoryOptions) AgentDelivery {
 			DownloadURL: "",
 		}
 
+	case driverType == provider.KubernetesDriver:
+		log.Debugf("using legacy shell delivery for kubernetes driver")
+		return &LegacyShellDelivery{
+			ExecFunc:    opts.ExecFunc,
+			DownloadURL: "",
+		}
+
 	case opts.IsRemoteDocker:
 		log.Debugf("using remote docker delivery (docker cp)")
 		return &RemoteDockerDelivery{
@@ -46,6 +54,7 @@ func NewAgentDelivery(opts FactoryOptions) AgentDelivery {
 			return &LocalDockerDelivery{
 				DockerCommand: opts.DockerCommand,
 				Environment:   opts.DockerEnv,
+				HelperImage:   opts.HelperImage,
 			}
 		}
 		log.Debugf("using remote docker delivery for non-local docker daemon")

pkg/agent/delivery/factory_test.go

@@ -17,7 +17,7 @@ func TestNewAgentDelivery_LocalDocker(t *testing.T) {
 				Driver: provider.DockerDriver,
 			},
 		},
-		DockerCommand: "docker",
+		DockerCommand: defaultDockerCmd,
 	}
 
 	d := NewAgentDelivery(opts)
@@ -73,17 +73,23 @@ func TestNewAgentDelivery_CustomDriver(t *testing.T) {
 	assert.Equal(t, PhasePostStart, d.Phase())
 }
 
-func TestNewAgentDelivery_KubernetesDriver_FallsToLegacy(t *testing.T) {
+func TestNewAgentDelivery_KubernetesDriver(t *testing.T) {
+	execFn := func(ctx context.Context, cmd string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
+		return nil
+	}
+
 	opts := FactoryOptions{
 		WorkspaceConfig: &provider.AgentWorkspaceInfo{
 			Agent: provider.ProviderAgentConfig{
 				Driver: provider.KubernetesDriver,
 			},
 		},
+		ExecFunc: execFn,
 	}
 
 	d := NewAgentDelivery(opts)
 	assert.IsType(t, &LegacyShellDelivery{}, d)
+	assert.Equal(t, PhasePostStart, d.Phase())
 }
 
 func TestIsDockerLocal(t *testing.T) {

pkg/agent/delivery/kubernetes.go

@@ -0,0 +1,57 @@
+package delivery
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/devsy-org/devsy/pkg/agent"
+	"github.com/devsy-org/devsy/pkg/inject"
+	"github.com/devsy-org/devsy/pkg/log"
+)
+
+var _ AgentDelivery = (*KubernetesDelivery)(nil)
+
+type KubernetesDelivery struct {
+	ExecFunc inject.ExecFunc
+}
+
+func (d *KubernetesDelivery) Phase() DeliveryPhase {
+	return PhasePostStart
+}
+
+func (d *KubernetesDelivery) DeliverPreStart(_ context.Context, _ PreStartOptions) error {
+	return fmt.Errorf("KubernetesDelivery does not support pre-start delivery")
+}
+
+func (d *KubernetesDelivery) DeliverPostStart(ctx context.Context, opts PostStartOptions) error {
+	if opts.BinarySource == nil {
+		return fmt.Errorf("binary source is required for kubernetes delivery")
+	}
+	if d.ExecFunc == nil {
+		return fmt.Errorf("exec function is required for kubernetes delivery")
+	}
+
+	binary, err := opts.BinarySource(ctx, opts.Arch)
+	if err != nil {
+		return fmt.Errorf("acquire binary: %w", err)
+	}
+	defer func() { _ = binary.Close() }()
+
+	destPath := agent.ContainerDevsyHelperLocation
+	script := fmt.Sprintf(
+		`set -e; t=$(mktemp %s.XXXXXX); cat > "$t" && chmod 755 "$t" && mv "$t" %s || { rm -f "$t"; exit 1; }`,
+		destPath,
+		destPath,
+	)
+
+	if err := d.ExecFunc(ctx, script, binary, nil, nil); err != nil {
+		return fmt.Errorf("write binary to container: %w", err)
+	}
+
+	log.Debugf("delivered agent binary to kubernetes container via exec")
+	return nil
+}
+
+func (d *KubernetesDelivery) Cleanup(_ context.Context, _ string) error {
+	return nil
+}

pkg/agent/delivery/kubernetes_test.go

@@ -0,0 +1,113 @@
+package delivery
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/devsy-org/devsy/pkg/agent"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKubernetesDelivery_Phase(t *testing.T) {
+	d := &KubernetesDelivery{}
+	assert.Equal(t, PhasePostStart, d.Phase())
+}
+
+func TestKubernetesDelivery_DeliverPreStart_ReturnsError(t *testing.T) {
+	d := &KubernetesDelivery{}
+	err := d.DeliverPreStart(context.Background(), PreStartOptions{})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "does not support pre-start")
+}
+
+func TestKubernetesDelivery_DeliverPostStart_RequiresBinarySource(t *testing.T) {
+	d := &KubernetesDelivery{
+		ExecFunc: func(_ context.Context, _ string, _ io.Reader, _ io.Writer, _ io.Writer) error {
+			return nil
+		},
+	}
+	err := d.DeliverPostStart(context.Background(), PostStartOptions{})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "binary source is required")
+}
+
+func TestKubernetesDelivery_DeliverPostStart_RequiresExecFunc(t *testing.T) {
+	d := &KubernetesDelivery{}
+	err := d.DeliverPostStart(context.Background(), PostStartOptions{
+		BinarySource: fakeBinarySource,
+	})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "exec function is required")
+}
+
+func TestKubernetesDelivery_DeliverPostStart_WritesBinary(t *testing.T) {
+	binaryData := "test-binary-content"
+	var capturedCmd string
+	var capturedStdin bytes.Buffer
+
+	execFn := func(_ context.Context, cmd string, stdin io.Reader, _ io.Writer, _ io.Writer) error {
+		capturedCmd = cmd
+		if stdin != nil {
+			_, _ = io.Copy(&capturedStdin, stdin)
+		}
+		return nil
+	}
+
+	d := &KubernetesDelivery{ExecFunc: execFn}
+	err := d.DeliverPostStart(context.Background(), PostStartOptions{
+		BinarySource: func(_ context.Context, _ string) (io.ReadCloser, error) {
+			return io.NopCloser(strings.NewReader(binaryData)), nil
+		},
+		Arch: "amd64",
+	})
+
+	require.NoError(t, err)
+
+	destPath := agent.ContainerDevsyHelperLocation
+	assert.Contains(t, capturedCmd, "cat >")
+	assert.Contains(t, capturedCmd, destPath)
+	assert.Contains(t, capturedCmd, "chmod 755")
+
+	assert.Equal(t, binaryData, capturedStdin.String())
+}
+
+func TestKubernetesDelivery_DeliverPostStart_BinarySourceError(t *testing.T) {
+	execFn := func(_ context.Context, _ string, _ io.Reader, _ io.Writer, _ io.Writer) error {
+		return nil
+	}
+
+	d := &KubernetesDelivery{ExecFunc: execFn}
+	err := d.DeliverPostStart(context.Background(), PostStartOptions{
+		BinarySource: func(_ context.Context, _ string) (io.ReadCloser, error) {
+			return nil, fmt.Errorf("download failed")
+		},
+	})
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "acquire binary")
+}
+
+func TestKubernetesDelivery_DeliverPostStart_ExecError(t *testing.T) {
+	execFn := func(_ context.Context, _ string, _ io.Reader, _ io.Writer, _ io.Writer) error {
+		return fmt.Errorf("exec failed")
+	}
+
+	d := &KubernetesDelivery{ExecFunc: execFn}
+	err := d.DeliverPostStart(context.Background(), PostStartOptions{
+		BinarySource: fakeBinarySource,
+	})
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "write binary to container")
+}
+
+func TestKubernetesDelivery_Cleanup_IsNoOp(t *testing.T) {
+	d := &KubernetesDelivery{}
+	err := d.Cleanup(context.Background(), "workspace-123")
+	assert.NoError(t, err)
+}