Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

15.9 KB
Raw Blame
package runtime

import (
	"context"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"agentflow/internal/domain"
)

func TestDockerConversationProcessPreservesInteractiveInput(t *testing.T) {
	requireConversationSubreaper(t)
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	pid := filepath.Join(t.TempDir(), "owned-process.pid")
	argv := dockerConversationProcessArgv(pid, []string{"sh", "-c", `read first; read second; printf '%s/%s' "$first" "$second"`})
	cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
	cmd.Stdin = strings.NewReader("initialize\nthread/resume\n")
	output, err := cmd.CombinedOutput()
	if err != nil || string(output) != "initialize/thread/resume" {
		t.Fatalf("interactive process lost input: %q %v", output, err)
	}
	if data, err := os.ReadFile(pid); err != nil || strings.TrimSpace(string(data)) == "" {
		t.Fatalf("process ownership PID not recorded: %q %v", data, err)
	}
}

func TestDockerSandboxLifecycleWithFakeCLI(t *testing.T) {
	workspace := t.TempDir()
	cvRInstallFakeDocker(t, workspace)
	dockerfile := domain.DockerfileDefinition{ID: "cvR", Content: "FROM scratch\n", Files: map[string]string{"asset.txt": "asset"}}
	sbAny, err := createDocker(context.Background(), "cvR-run", workspace,
		domain.SandboxProfile{Driver: "docker", ReadOnlyRootFS: true, Environment: map[string]string{"A": "1"}},
		SandboxRequirements{BunFS: true}, dockerfile)
	if err != nil {
		t.Fatal(err)
	}
	sb := sbAny.(*dockerSandbox)
	if sb.ID() != "cvR-run" || sb.Workspace() != workspace || sb.Driver() != "docker" {
		t.Fatalf("sandbox=%+v", sb)
	}
	const extraValue = "test-extra-credential"
	command, err := bindCommand(sb, workspace, CommandSpec{
		Argv:               []string{"sh", "-lc", "echo ok"},
		CredentialBindings: []CredentialBinding{BindExtra},
		ExtraCredentialEnv: map[string]string{"DEPLOYMENT_VALUE": "registry"},
		environment:        map[string]string{"B": "2"},
	}, RunCredentials{Extra: map[string]string{"registry": extraValue}})
	if err != nil {
		t.Fatal(err)
	}
	var started string
	out, err := sb.Exec(context.Background(), command, func(event domain.TelemetryEvent) {
		if event.Name == "process.started" {
			started = event.Message
		}
	})
	if err != nil || !strings.Contains(out, "/workspace") {
		t.Fatalf("exec=%q err=%v", out, err)
	}
	if strings.Contains(started, extraValue) || !strings.Contains(started, "DEPLOYMENT_VALUE=<redacted>") || !strings.Contains(started, "B=2") {
		t.Fatalf("process.started must redact the extra credential and keep ordinary environment variables: %q", started)
	}
	if !sb.started || sb.builtImage == "" {
		t.Fatalf("sandbox did not start: %+v", sb)
	}
	if err := sb.BindWorkspace(context.Background()); err != nil {
		t.Fatal(err)
	}
	sb.invalidate()
	if sb.started {
		t.Fatal("invalidate retained started")
	}
	if err := sb.Recreate(context.Background()); err != nil {
		t.Fatal(err)
	}
	if err := sb.Close(context.Background()); err != nil {
		t.Fatal(err)
	}
}

func TestDockerSandboxUsesRelayNetworkOnlyWhenRequested(t *testing.T) {
	for _, tc := range []struct {
		name               string
		privateHome        bool
		conversation       bool
		runnerLoginRelay   bool
		invalidRelayConfig bool
		wantNetwork        string
	}{
		{name: "SOP with private home", privateHome: true, wantNetwork: "sop-network"},
		{name: "SOP ignores invalid conversation settings", privateHome: true, invalidRelayConfig: true, wantNetwork: "sop-network"},
		{name: "conversation", conversation: true, wantNetwork: "chat-network"},
		{name: "Codex login relay", runnerLoginRelay: true, wantNetwork: "chat-network"},
	} {
		t.Run(tc.name, func(t *testing.T) {
			workspace := t.TempDir()
			cvRInstallFakeDocker(t, workspace)
			argsFile := filepath.Join(t.TempDir(), "create-args")
			t.Setenv("CVR_DOCKER_CREATE_ARGS", argsFile)
			t.Setenv("AGENTFLOW_DOCKER_NETWORK", "sop-network")
			t.Setenv("AGENTFLOW_CONVERSATION_DOCKER_NETWORK", "chat-network")
			host := "host.docker.internal"
			if tc.invalidRelayConfig {
				host = "invalid/relay"
			}
			t.Setenv("AGENTFLOW_CONVERSATION_RELAY_HOST", host)
			requirements := SandboxRequirements{PrivateHome: tc.privateHome, RunnerLoginRelay: tc.runnerLoginRelay}
			if tc.conversation {
				requirements.ConversationRoot = t.TempDir()
			}
			ctx := context.Background()
			sandbox, err := createDocker(ctx, "network-policy", workspace, domain.SandboxProfile{Driver: "docker"}, requirements, domain.DockerfileDefinition{Content: "FROM scratch"})
			if err != nil {
				t.Fatal(err)
			}
			defer sandbox.Close(ctx)
			if err := sandbox.(*dockerSandbox).BindWorkspace(ctx); err != nil {
				t.Fatal(err)
			}
			data, err := os.ReadFile(argsFile)
			if err != nil {
				t.Fatal(err)
			}
			args := string(data)
			if strings.Count(args, "\n--network\n") != 1 || !strings.Contains(args, "\n--network\n"+tc.wantNetwork+"\n") {
				t.Fatalf("docker create used the wrong network: %s", args)
			}
			usesGateway := strings.Contains(args, "\n--add-host\nhost.docker.internal:host-gateway\n")
			if usesGateway != (tc.conversation || tc.runnerLoginRelay) {
				t.Fatalf("docker create host gateway = %v for %s", usesGateway, tc.name)
			}
		})
	}
}

func TestDockerDiscoveryImagesAndBuildHelpers(t *testing.T) {
	workspace := t.TempDir()
	cvRInstallFakeDocker(t, workspace)
	ctx := context.Background()
	info, err := inspectDockerWorkspaceMounts(ctx, "box")
	if err != nil || info == nil || info.source != workspace || info.legacyMasks {
		t.Fatalf("mounts=%+v err=%v", info, err)
	}
	found, err := dockerSandboxesUnder(ctx, filepath.Dir(workspace))
	if err != nil || found["agentflow-cvr"] != filepath.Base(workspace) {
		t.Fatalf("found=%v err=%v", found, err)
	}
	mounts, err := collectDockerSandboxMounts(ctx, []string{"id1"})
	if err != nil || !strings.Contains(mounts, "agentflow-cvr") {
		t.Fatalf("mounts=%q err=%v", mounts, err)
	}
	if !dockerObjectGone("No such container", os.ErrNotExist) || dockerObjectGone("", nil) {
		t.Fatal("docker gone classification")
	}
	listed, err := listCachedDockerImages(ctx)
	if err != nil || len(listed) != 2 {
		t.Fatalf("listed=%v err=%v", listed, err)
	}
	inUse, err := cachedDockerImagesInUse(ctx)
	if err != nil || len(inUse) != 1 {
		t.Fatalf("inUse=%v err=%v", inUse, err)
	}
	removed, err := reclaimCachedDockerImages(ctx, map[string]struct{}{})
	if err != nil || removed != 1 {
		t.Fatalf("removed=%d err=%v", removed, err)
	}
	if got := staleCachedDockerImages([]string{"agentflow-img-a", "other"}, map[string]struct{}{}, map[string]struct{}{}); len(got) != 1 {
		t.Fatalf("stale=%v", got)
	}
	if normalizeCachedDockerImageName("agentflow-img-a:latest") != "agentflow-img-a" || normalizeCachedDockerImageName("ubuntu") != "" {
		t.Fatal("image normalization")
	}
	dockerfile := domain.DockerfileDefinition{ID: "../bad", Content: "FROM scratch", Files: map[string]string{"Dockerfile": "ignored", "sub/a": "a"}}
	dir, err := prepareDockerfileBuildContext(workspace, dockerfile)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(filepath.Join(dir, "sub", "a")); err != nil {
		t.Fatal(err)
	}
	image, err := ensureDockerImage(ctx, workspace, dockerfile)
	if err != nil || !strings.HasPrefix(image, dockerCachedImagePrefix) {
		t.Fatalf("image=%q err=%v", image, err)
	}
	if _, err := createDocker(ctx, "x", workspace, domain.SandboxProfile{}, SandboxRequirements{}, domain.DockerfileDefinition{}); err == nil {
		t.Fatal("empty dockerfile accepted")
	}
}

func TestDockerArgumentAndErrorBranches(t *testing.T) {
	if got := dockerWorkspaceExecArgv(nil); !strings.Contains(strings.Join(got, " "), "pwd") {
		t.Fatalf("argv=%v", got)
	}
	got := dockerWorkspaceExecArgv([]string{"bash", "-lc", "echo x"})
	if len(got) < 3 || got[len(got)-2] != "-c" || !cvRContains(got, "-c") {
		t.Fatalf("login flag retained: %v", got)
	}
	if out := dropShellLoginFlag([]string{"tool", "-lc"}); out[1] != "-lc" {
		t.Fatalf("non-shell changed: %v", out)
	}
	for _, text := range []string{"No such exec instance", "No such container", "container not found", "Error response from daemon: box is not running"} {
		err := os.ErrNotExist
		if !looksLikeDockerExecGone(text) || !isMissingDockerExec(cvRErrorsJoin(err, text)) || !IsSandboxInterrupt(cvRErrorsJoin(err, text)) {
			t.Fatalf("not classified: %s", text)
		}
	}
	if !IsSandboxInterrupt(context.Canceled) || IsSandboxInterrupt(nil) {
		t.Fatal("interrupt classification")
	}
	if !IsCwdMountFailure(cvRErrorsJoin(os.ErrInvalid, "exit status 126")) || isDockerCwdUnsafe("", nil) {
		t.Fatal("cwd classification")
	}
	line := "Error response from daemon: No such container: box"
	if excerpt := dockerInterruptExcerpt("noise\n" + line + "\n"); excerpt != line {
		t.Fatalf("excerpt=%q", excerpt)
	}
	if annotateDockerExecError(line, os.ErrInvalid) == os.ErrInvalid {
		t.Fatal("docker error was not annotated")
	}
	if !ephemeralDockerImage(tempDockerImageName("x")) || ephemeralDockerImage(dockerCachedImagePrefix+"x") {
		t.Fatal("ephemeral image classification")
	}
}

func TestDockerManagerReclaimsCachedImages(t *testing.T) {
	workspace := t.TempDir()
	cvRInstallFakeDocker(t, workspace)
	m := NewManager(workspace)
	count, err := m.ReclaimCachedDockerImages(context.Background(), nil)
	if err != nil || count != 1 {
		t.Fatalf("manager image reclaim=%d err=%v", count, err)
	}
}

func TestDockerExecRecoversFromUnsafeCWD(t *testing.T) {
	workspace := t.TempDir()
	bin := t.TempDir()
	marker := filepath.Join(t.TempDir(), "failed-once")
	script := `#!/bin/sh
workspace="${CVR_DOCKER_WORKSPACE}"
marker="${CVR_DOCKER_MARKER}"
if [ "${1-}" = inspect ]; then
  printf '[{"Destination":"/workspace","Source":"%s"}]\n' "$workspace"
  exit 0
fi
if [ "${1-}" = exec ]; then
  case "$*" in *"cd /workspace && pwd"*) echo /workspace; exit 0;; esac
  if [ ! -e "$marker" ]; then
    : > "$marker"
    echo 'OCI runtime exec failed: cwd is outside of container mount namespace'
    exit 126
  fi
  echo recovered
  exit 0
fi
exit 0
`
	if err := os.WriteFile(filepath.Join(bin, "docker"), []byte(script), 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
	t.Setenv("CVR_DOCKER_WORKSPACE", workspace)
	t.Setenv("CVR_DOCKER_MARKER", marker)
	sb := &dockerSandbox{id: "recover", name: "box", workspace: workspace, started: true}
	out, err := sb.Exec(context.Background(), CommandSpec{Argv: []string{"sh", "-c", "echo x"}}, nil)
	if err != nil || !strings.Contains(out, "recovered") || !sb.started {
		t.Fatalf("out=%q started=%v err=%v", out, sb.started, err)
	}
}

func TestDockerExecInvalidatesMissingContainer(t *testing.T) {
	bin := t.TempDir()
	if err := os.WriteFile(filepath.Join(bin, "docker"), []byte("#!/bin/sh\necho 'Error: No such container: box'\nexit 1\n"), 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
	sb := &dockerSandbox{name: "box", workspace: t.TempDir(), started: true}
	if _, err := sb.Exec(context.Background(), CommandSpec{Argv: []string{"true"}}, nil); err == nil || sb.started {
		t.Fatalf("started=%v err=%v", sb.started, err)
	}
}

func TestSandboxEnvironmentIdentityRecoversExternallyStoppedOrRemovedContainer(t *testing.T) {
	bin, state := t.TempDir(), t.TempDir()
	// A stateful docker stand-in: "status" holds running/exited, "generation"
	// counts docker create and "starts" counts docker start.
	script := `#!/bin/sh
state="${CVR_DOCKER_STATE}"
status() { cat "$state/status" 2>/dev/null; }
count() { n=$(cat "$state/$1" 2>/dev/null || echo 0); echo $((n + 1)) > "$state/$1"; }
case "$*" in
  "inspect --format {{.State.Running}}|{{.Id}}|{{.State.StartedAt}} box")
    case "$(status)" in
      running) echo "true|id-$(cat "$state/generation")|start-$(cat "$state/starts")"; exit 0 ;;
      exited) echo "false|id-$(cat "$state/generation")|start-$(cat "$state/starts")"; exit 0 ;;
    esac
    echo 'Error: No such object: box' >&2; exit 1 ;;
  "inspect --type container --format {{json .Mounts}} box")
    [ -n "$(status)" ] || { echo 'Error: No such container: box' >&2; exit 1; }
    printf '[{"Destination":"/workspace","Source":"%s"}]\n' "$CVR_DOCKER_WORKSPACE"; exit 0 ;;
  "start box") [ -n "$(status)" ] || exit 1; echo running > "$state/status"; count starts; exit 0 ;;
  "create --name box "*) echo exited > "$state/status"; count generation; exit 0 ;;
  "rm -f box") rm -f "$state/status"; exit 0 ;;
  "exec box "*) [ "$(status)" = running ] || { echo 'Error response from daemon: container box is not running' >&2; exit 1; }
    case "$*" in *"cd /workspace && pwd"*) echo /workspace ;; esac; exit 0 ;;
  "image inspect --format {{.Config.User}} "*) exit 0 ;;
  "image inspect "*) exit 0 ;;
esac
exit 0
`
	if err := os.WriteFile(filepath.Join(bin, "docker"), []byte(script), 0o755); err != nil {
		t.Fatal(err)
	}
	workspace := t.TempDir()
	t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
	t.Setenv("CVR_DOCKER_STATE", state)
	t.Setenv("CVR_DOCKER_WORKSPACE", workspace)
	for name, value := range map[string]string{"status": "running", "generation": "1", "starts": "1"} {
		if err := os.WriteFile(filepath.Join(state, name), []byte(value+"\n"), 0o644); err != nil {
			t.Fatal(err)
		}
	}
	ctx := context.Background()
	sb := &dockerSandbox{id: "box", name: "box", workspace: workspace, started: true,
		dockerfile: domain.DockerfileDefinition{Content: "FROM alpine:3.20\n"}}
	identity, err := SandboxEnvironmentIdentity(ctx, sb)
	if err != nil {
		t.Fatal(err)
	}
	for _, external := range []string{"stopped", "removed"} {
		if external == "stopped" {
			err = os.WriteFile(filepath.Join(state, "status"), []byte("exited\n"), 0o644)
		} else {
			err = os.Remove(filepath.Join(state, "status"))
		}
		if err != nil {
			t.Fatal(err)
		}
		// The first call after an external stop/removal recovers; it must not
		// keep failing on the cached started flag.
		next, err := SandboxEnvironmentIdentity(ctx, sb)
		if err != nil || next == identity || !sb.started {
			t.Fatalf("container %s: identity %q (was %q) started=%v err=%v", external, next, identity, sb.started, err)
		}
		if again, err := SandboxEnvironmentIdentity(ctx, sb); err != nil || again != next {
			t.Fatalf("container %s: identity unstable %q != %q %v", external, again, next, err)
		}
		identity = next
	}
	if data, err := os.ReadFile(filepath.Join(state, "generation")); err != nil || strings.TrimSpace(string(data)) != "2" {
		t.Fatalf("removed container was not recreated exactly once: %q %v", data, err)
	}
}

func cvRInstallFakeDocker(t *testing.T, workspace string) {
	t.Helper()
	bin := t.TempDir()
	script := `#!/bin/sh
set -eu
workspace="${CVR_DOCKER_WORKSPACE}"
if [ "${1-}" = inspect ] && [ "${2-}" = -f ]; then
  printf '/agentflow-cvr\t%s\n' "$workspace"
  exit 0
fi
case "$*" in
  "inspect --type container --format {{json .Mounts}} box")
    printf '[{"Destination":"/workspace","Source":"%s"}]\n' "$workspace"; exit 0 ;;
  "inspect --type container "*) echo 'Error: No such container' >&2; exit 1 ;;
  "inspect --format {{.State.Running}}|{{.Id}}|{{.State.StartedAt}} "*) echo 'true|container-id|now'; exit 0 ;;
  "image inspect --format {{.Config.User}} "*) exit 0 ;;
  "image inspect "*) exit 1 ;;
  "images --format {{.Repository}} --filter reference=agentflow-img-*"*) printf 'agentflow-img-a:latest\nagentflow-img-b\nagentflow-img-a\n'; exit 0 ;;
  "ps -a --format {{.Image}}"*) echo agentflow-img-b; exit 0 ;;
  "ps -aq --filter "*) echo id1; exit 0 ;;
  "inspect "*) exit 1 ;;
  "exec "*) echo /workspace; exit 0 ;;
  "create "*)
    if [ -n "${CVR_DOCKER_CREATE_ARGS:-}" ]; then printf '%s\n' "$@" > "$CVR_DOCKER_CREATE_ARGS"; fi
    exit 0 ;;
  *) exit 0 ;;
esac
`
	path := filepath.Join(bin, "docker")
	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv("CVR_DOCKER_WORKSPACE", workspace)
	t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
}

func cvRErrorsJoin(base error, text string) error {
	return &cvRTextError{base: base, text: text}
}

type cvRTextError struct {
	base error
	text string
}

func (e *cvRTextError) Error() string { return e.text + ": " + e.base.Error() }
func (e *cvRTextError) Unwrap() error { return e.base }