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.

23.2 KB
Raw Blame
package httpapi

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"agentflow/internal/domain"

	"github.com/gin-gonic/gin"
)

func cvBGit(t *testing.T, dir string, args ...string) string {
	t.Helper()
	out, err := exec.Command("git", append([]string{"-C", dir}, args...)...).CombinedOutput()
	if err != nil {
		t.Fatalf("git %v: %v: %s", args, err, out)
	}
	return strings.TrimSpace(string(out))
}

func cvBWrite(t *testing.T, path string, body []byte) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(path, body, 0o644); err != nil {
		t.Fatal(err)
	}
}

func TestWorkspaceMoreFilesystemGitPaths(t *testing.T) {
	root := t.TempDir()
	for _, name := range []string{"one", "two"} {
		dir := filepath.Join(root, name)
		cvBWrite(t, filepath.Join(dir, "tracked.txt"), []byte("first\n"))
		cvBWrite(t, filepath.Join(dir, ".env.example"), []byte("example\n"))
		cvBWrite(t, filepath.Join(dir, ".env"), []byte("secret\n"))
		cvBWrite(t, filepath.Join(dir, "binary.dat"), []byte{'a', 0, 'b'})
		cvBWrite(t, filepath.Join(dir, "large.dat"), bytes.Repeat([]byte("z"), workspaceFileLimit+1))
		cvBWrite(t, filepath.Join(dir, "diffbig.txt"), bytes.Repeat([]byte("old line\n"), 150000))
		cvBGit(t, dir, "init")
		cvBGit(t, dir, "config", "user.email", "[email protected]")
		cvBGit(t, dir, "config", "user.name", "cvB")
		cvBGit(t, dir, "add", ".")
		cvBGit(t, dir, "commit", "-m", "initial "+name)
	}
	run := domain.Run{Repositories: []domain.RepositoryContext{
		{RepositoryID: "one", WorkspaceDir: "one"},
		{RepositoryID: "bad", WorkspaceDir: "../outside"},
		{RepositoryID: "two", WorkspaceDir: "two"},
	}}
	roots := workspaceRepositoryRoots(root, run)
	if len(roots) != 2 || roots[0].label != "one" || roots[1].label != "two" {
		t.Fatalf("repository roots: %#v", roots)
	}
	if got := collectWorkspaceGitRepositories(root, run); len(got) != 2 {
		t.Fatalf("git repositories: %#v", got)
	}
	if _, _, ok := findWorkspaceRepository(root, run, "workspace"); ok {
		t.Fatal("ambiguous workspace repository resolved")
	}
	if path, label, ok := findWorkspaceRepository(root, run, "one"); !ok || path != filepath.Join(root, "one") || label != "one" {
		t.Fatalf("find one: %q %q %v", path, label, ok)
	}

	cvBWrite(t, filepath.Join(root, "one", "tracked.txt"), []byte("changed\n"))
	cvBGit(t, filepath.Join(root, "one"), "mv", "tracked.txt", "renamed.txt")
	cvBWrite(t, filepath.Join(root, "one", "diffbig.txt"), bytes.Repeat([]byte("new line\n"), 150000))
	cvBWrite(t, filepath.Join(root, "two", ".env.local"), []byte("hidden\n"))
	cvBWrite(t, filepath.Join(root, "two", "new.txt"), []byte("new\n"))
	changes, warning := collectWorkspaceChanges(context.Background(), root, run)
	if warning != "" || len(changes) < 2 {
		t.Fatalf("changes: %#v warning=%q", changes, warning)
	}
	for _, change := range changes {
		if strings.Contains(change.Path, ".env.local") {
			t.Fatalf("sensitive change leaked: %#v", change)
		}
	}
	diff, clipped, err := readWorkspaceDiff(context.Background(), root, run, "one/renamed.txt")
	if err != nil || clipped || diff == "" {
		t.Fatalf("renamed diff: %q %v %v", diff, clipped, err)
	}
	cvBWrite(t, filepath.Join(root, "unrelated.txt"), []byte("outside repositories\n"))
	_, _, _ = readWorkspaceDiff(context.Background(), root, run, "unrelated.txt")
	if diff, clipped, err = readWorkspaceDiff(context.Background(), root, run, ""); err != nil || !clipped || len(diff) != workspaceFileLimit {
		t.Fatalf("large diff: %d %v %v", len(diff), clipped, err)
	}
	base, clipped, err := readWorkspaceBaseFile(context.Background(), root, run, "two/new.txt")
	if err != nil || clipped || base != "" {
		t.Fatalf("untracked base: %q %v %v", base, clipped, err)
	}
	if _, _, err = readWorkspaceBaseFile(context.Background(), root, run, "missing.txt"); !os.IsNotExist(err) {
		t.Fatalf("missing base error = %v", err)
	}

	head := cvBGit(t, filepath.Join(root, "one"), "rev-parse", "HEAD")
	if files, err := collectWorkspaceCommitFiles(context.Background(), root, run, "one", head); err != nil || len(files) != 5 {
		t.Fatalf("commit files: %#v %v", files, err)
	}
	if files, err := collectWorkspaceCommitFiles(context.Background(), root, run, "missing", head); err == nil || files != nil {
		t.Fatalf("missing repository commit: %#v %v", files, err)
	}
	if files, err := collectWorkspaceCommitFiles(context.Background(), root, run, "two", "abcdef0"); err == nil || files != nil {
		t.Fatalf("missing commit object: %#v %v", files, err)
	}
	if blob, size, err := readWorkspaceGitBlob(context.Background(), root, run, "two/new.txt", head); err != nil || blob != "" || size != 0 {
		t.Fatalf("cross-repository blob: %q %d %v", blob, size, err)
	}
	if blob, size, err := readWorkspaceGitBlob(context.Background(), root, run, "one", head); err != nil || blob != "" || size != 0 {
		t.Fatalf("directory blob: %q %d %v", blob, size, err)
	}
	if _, _, err := readWorkspaceGitBlob(context.Background(), root, run, ".env", head); err == nil {
		t.Fatal("sensitive blob path accepted")
	}
	if _, _, err := readWorkspaceGitBlob(context.Background(), root, run, "one/binary.dat", head); err == nil {
		t.Fatal("binary git blob accepted")
	}
	if blob, size, err := readWorkspaceGitBlob(context.Background(), root, run, "one/large.dat", head); err != nil || len(blob) != workspaceFileLimit || size != workspaceFileLimit {
		t.Fatalf("large git blob: %d %d %v", len(blob), size, err)
	}
	if _, _, err := readWorkspaceBaseFile(context.Background(), root, run, "one/binary.dat"); err == nil {
		t.Fatal("binary base file accepted")
	}
	if base, clipped, err := readWorkspaceBaseFile(context.Background(), root, run, "one/large.dat"); err != nil || !clipped || len(base) != workspaceFileLimit {
		t.Fatalf("large base file: %d %v %v", len(base), clipped, err)
	}

	plainRoot := t.TempDir()
	plainRun := domain.Run{}
	if log, err := collectWorkspaceLog(context.Background(), plainRoot, plainRun, ""); err != nil || log["head"] != "" {
		t.Fatalf("plain log: %#v %v", log, err)
	}
	if files, err := collectWorkspaceCommitFiles(context.Background(), plainRoot, plainRun, "", head); err != nil || len(files) != 0 {
		t.Fatalf("plain commit files: %#v %v", files, err)
	}
	if _, err := collectWorkspaceLog(context.Background(), root, run, "missing"); err == nil {
		t.Fatal("missing repository log accepted")
	}
	brokenRoot := t.TempDir()
	cvBWrite(t, filepath.Join(brokenRoot, ".git"), []byte("not a repository"))
	if changes, warning := collectWorkspaceChanges(context.Background(), brokenRoot, domain.Run{}); warning == "" || len(changes) != 0 {
		t.Fatalf("broken repository changes: %#v %q", changes, warning)
	}

	large := bytes.Repeat([]byte("x"), workspaceFileLimit+1)
	cvBWrite(t, filepath.Join(root, "large.txt"), large)
	if _, size, err := readWorkspaceFile(root, "large.txt"); err == nil || size != int64(len(large)) {
		t.Fatalf("large preview: size=%d err=%v", size, err)
	}
	for i := 0; i < 101; i++ {
		cvBWrite(t, filepath.Join(root, "search", string(rune('a'+i%26)), strings.Repeat("x", i/26)+".txt"), []byte("needle\n"))
	}
	results, truncated, err := searchWorkspace(context.Background(), root, "needle")
	if err != nil || !truncated || len(results) != 100 {
		t.Fatalf("search limit: %d %v %v", len(results), truncated, err)
	}
	cancelled, cancel := context.WithCancel(context.Background())
	cancel()
	if _, _, err := searchWorkspace(cancelled, root, "needle"); err == nil {
		t.Fatal("cancelled search succeeded")
	}
}

func TestWorkspaceMoreRemoteProxyMatrix(t *testing.T) {
	gin.SetMode(gin.TestMode)
	f := cvBNewHTTPFixture(t)
	run := domain.Run{
		ID: "cvb-remote-more", Status: "running", PauseRequested: true, Nodes: map[string]*domain.NodeRun{},
		ExecutionContext: domain.TelemetryContext{ExecutionMode: domain.ExecutionModeRunner, ExecutionRunnerID: "cvb-runner"},
	}
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutRunner(domain.Runner{ID: "cvb-runner", Status: domain.RunnerStatusOnline}); err != nil {
		t.Fatal(err)
	}
	hub := newRunnerControlHub()
	conn := &runnerControlConn{runnerID: "cvb-runner", send: make(chan runnerControlMessage, 20), done: make(chan struct{})}
	hub.conns[conn.runnerID] = conn
	h := &runsHandlers{deps: &deps{repo: f.s, engine: f.e}, runnerControls: hub}
	done := make(chan struct{})
	go func() {
		defer close(done)
		for message := range conn.send {
			request := message.WorkspaceRequest
			switch request.Query {
			case "error404":
				hub.resolveWorkspace(message.RequestID, domain.RunnerWorkspaceResponse{Status: http.StatusNotFound, Error: "missing"})
				continue
			case "badstatus":
				hub.resolveWorkspace(message.RequestID, domain.RunnerWorkspaceResponse{Status: http.StatusOK, Error: "bad"})
				continue
			case "empty":
				hub.resolveWorkspace(message.RequestID, domain.RunnerWorkspaceResponse{})
				continue
			case "invalidjson":
				hub.resolveWorkspace(message.RequestID, domain.RunnerWorkspaceResponse{Payload: []byte("{")})
				continue
			}
			payload, _ := json.Marshal(gin.H{"available": true, "operation": request.Operation})
			hub.resolveWorkspace(message.RequestID, domain.RunnerWorkspaceResponse{Payload: payload})
		}
	}()
	t.Cleanup(func() {
		close(conn.send)
		<-done
	})

	paths := []string{
		"/api/runs/:id/workspace",
		"/api/runs/:id/workspace/tree",
		"/api/runs/:id/workspace/file",
		"/api/runs/:id/workspace/log",
		"/api/runs/:id/workspace/commit",
		"/api/runs/:id/workspace/diff",
		"/api/runs/:id/workspace/search",
	}
	for _, fullPath := range paths {
		rec := httptest.NewRecorder()
		router := gin.New()
		router.GET(fullPath, h.runWorkspace)
		router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, strings.Replace(fullPath, ":id", run.ID, 1)+"?path=a&repository=one&id=abcdef0&q=needle", nil))
		if rec.Code != http.StatusOK {
			t.Errorf("%s = %d: %s", fullPath, rec.Code, rec.Body.String())
		}
	}
	for _, tc := range []struct {
		path  string
		query string
		want  int
	}{
		{paths[0], "error404", http.StatusOK},
		{paths[6], "badstatus", http.StatusBadRequest},
		{paths[6], "empty", http.StatusBadGateway},
		{paths[0], "invalidjson", http.StatusOK},
	} {
		rec := httptest.NewRecorder()
		testRouter := gin.New()
		testRouter.GET(tc.path, h.runWorkspace)
		requestPath := strings.Replace(tc.path, ":id", run.ID, 1)
		testRouter.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, requestPath+"?q="+tc.query, nil))
		if rec.Code != tc.want {
			t.Errorf("proxy %s %s = %d want %d: %s", tc.path, tc.query, rec.Code, tc.want, rec.Body.String())
		}
	}

	unavailable := &runsHandlers{deps: h.deps, runnerControls: newRunnerControlHub()}
	for _, fullPath := range []string{paths[0], paths[2]} {
		rec := httptest.NewRecorder()
		router := gin.New()
		router.GET(fullPath, unavailable.runWorkspace)
		router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, strings.Replace(fullPath, ":id", run.ID, 1), nil))
		want := http.StatusConflict
		if fullPath == paths[0] {
			want = http.StatusOK
		}
		if rec.Code != want {
			t.Errorf("unavailable %s = %d want %d", fullPath, rec.Code, want)
		}
	}

	rec := httptest.NewRecorder()
	router := gin.New()
	router.GET("/unexpected", func(c *gin.Context) { h.proxyRunnerWorkspace(c, run, "cvb-runner") })
	router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/unexpected", nil))
	if rec.Code != http.StatusNotFound {
		t.Fatalf("unexpected operation = %d", rec.Code)
	}
	rec = httptest.NewRecorder()
	router = gin.New()
	router.GET(paths[0], func(c *gin.Context) { (&runsHandlers{deps: h.deps}).proxyRunnerWorkspace(c, run, "cvb-runner") })
	router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, strings.Replace(paths[0], ":id", run.ID, 1), nil))
	if rec.Code != http.StatusServiceUnavailable {
		t.Fatalf("nil remote channel = %d", rec.Code)
	}

	local := domain.Run{ID: "cvb-local-missing", Status: "succeeded", Nodes: map[string]*domain.NodeRun{}}
	if err := f.s.PutRun(local); err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		path string
		want int
	}{{"/api/runs/cvb-local-missing/workspace", http.StatusOK}, {"/api/runs/cvb-local-missing/workspace/tree", http.StatusConflict}} {
		rec := cvBRequest(t, f, http.MethodGet, tc.path, nil, true)
		if rec.Code != tc.want {
			t.Errorf("missing local workspace %s = %d want %d", tc.path, rec.Code, tc.want)
		}
	}
}

func TestWorkspaceMoreEditAuthorizationAndErrors(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	run := domain.Run{ID: "cvb-edit-more", Status: "succeeded", ExecutionContext: domain.TelemetryContext{ProjectID: "cvb-view-only"}, Nodes: map[string]*domain.NodeRun{}}
	if err := f.s.PutProject(domain.Project{ID: "cvb-view-only", Name: "view", OwnerID: 0, Members: []domain.ProjectMember{{UserID: f.user.ID, Role: "viewer"}, {UserID: 999999, Role: "maintainer"}}}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	root := f.e.RunWorkspace(run.ID)
	cvBWrite(t, filepath.Join(root, "note.txt"), []byte("old"))
	if rec := cvBRequest(t, f, http.MethodGet, "/api/runs/"+run.ID+"/workspace/diff?path=missing.txt", nil, true); rec.Code != http.StatusNotFound {
		t.Fatalf("missing diff = %d: %s", rec.Code, rec.Body.String())
	}
	direct := &runsHandlers{deps: &deps{repo: f.s, engine: f.e}}
	custom := gin.New()
	custom.GET("/custom/:id", direct.runWorkspace)
	customRec := httptest.NewRecorder()
	custom.ServeHTTP(customRec, httptest.NewRequest(http.MethodGet, "/custom/"+run.ID, nil))
	if customRec.Code != http.StatusNotFound {
		t.Fatalf("unknown workspace operation = %d", customRec.Code)
	}

	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+run.ID+"/workspace/takeover", nil, false); rec.Code != http.StatusUnauthorized {
		t.Fatalf("anonymous takeover = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+run.ID+"/workspace/takeover", nil, true); rec.Code != http.StatusForbidden {
		t.Fatalf("viewer takeover = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+run.ID+"/workspace/file", nil, true); rec.Code != http.StatusForbidden {
		t.Fatalf("viewer write = %d: %s", rec.Code, rec.Body.String())
	}

	running := domain.Run{ID: "cvb-edit-running", Status: "running", ExecutionContext: domain.TelemetryContext{ProjectID: "platform"}, Nodes: map[string]*domain.NodeRun{}}
	if err := f.s.PutRun(running); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+running.ID+"/workspace/takeover", nil, true); rec.Code != http.StatusOK {
		t.Fatalf("running takeover = %d: %s", rec.Code, rec.Body.String())
	}

	owned := run
	owned.ID = "cvb-edit-owned"
	owned.ExecutionContext.ProjectID = "platform"
	owned.Nodes = map[string]*domain.NodeRun{"child": {ChildRunID: "nested"}}
	if err := f.s.PutRun(owned); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+owned.ID+"/workspace/takeover", nil, true); rec.Code != http.StatusConflict {
		t.Fatalf("parent with child takeover = %d: %s", rec.Code, rec.Body.String())
	}
	cleanOwned := owned
	cleanOwned.ID = "cvb-edit-clean"
	cleanOwned.Nodes = map[string]*domain.NodeRun{}
	cleanOwned.WorkspaceRoot = t.TempDir()
	cleanOwned.WorkspaceEditorID = f.user.ID
	cleanOwned.WorkspaceEditUntil = time.Now().UTC().Add(time.Hour)
	if err := f.s.PutRun(cleanOwned); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+cleanOwned.ID+"/workspace/file", "not-an-object", true); rec.Code != http.StatusBadRequest {
		t.Fatalf("invalid write body = %d: %s", rec.Code, rec.Body.String())
	}

	h := &runsHandlers{deps: &deps{repo: f.s, engine: f.e}}
	for _, status := range []string{"running", "waiting", "succeeded", "failed", "cancelled"} {
		probe := cleanOwned
		probe.Status = status
		probe.PauseRequested = status == "waiting"
		rec := httptest.NewRecorder()
		c, _ := gin.CreateTestContext(rec)
		c.Request = authedRequest(t, httptest.NewRequest(http.MethodGet, "/", nil), f.user)
		// People edit at any time, also while agents run.
		got := h.workspaceWritable(c, probe)
		want := true
		if got != want {
			t.Errorf("workspaceWritable(%s) = %v want %v", status, got, want)
		}
	}

	remote := owned
	remote.ID = "cvb-close-remote"
	remote.ExecutionContext.ExecutionMode = domain.ExecutionModeRunner
	remote.ExecutionContext.ExecutionRunnerID = "cvb-runner"
	if err := f.s.PutRunner(domain.Runner{ID: "cvb-runner", Status: domain.RunnerStatusOnline}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutRun(remote); err != nil {
		t.Fatal(err)
	}
	if err := h.closeWorkspaceTerminals(context.Background(), remote, f.user.ID); err == nil {
		t.Fatal("remote close without channel succeeded")
	}
}

func TestWorkspaceDeletedFileCancelledSearchAndTimeout(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	run := domain.Run{ID: "cvb-r2-workspace-edge", Status: "succeeded",
		ExecutionContext: domain.TelemetryContext{ProjectID: "platform"}, Nodes: map[string]*domain.NodeRun{}}
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	root := f.e.RunWorkspace(run.ID)
	cvBWrite(t, filepath.Join(root, "deleted.txt"), []byte("tracked\n"))
	cvBGit(t, root, "init")
	cvBGit(t, root, "config", "user.email", "[email protected]")
	cvBGit(t, root, "config", "user.name", "cvB")
	cvBGit(t, root, "add", "deleted.txt")
	cvBGit(t, root, "commit", "-m", "tracked")
	if err := os.Remove(filepath.Join(root, "deleted.txt")); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodGet,
		"/api/runs/"+run.ID+"/workspace/diff?path=deleted.txt", nil, true); rec.Code != http.StatusNotFound {
		t.Fatalf("deleted diff = %d: %s", rec.Code, rec.Body.String())
	}
	cvBWrite(t, filepath.Join(root, "live.txt"), []byte("tracked\n"))

	h := &runsHandlers{deps: &deps{repo: f.s, engine: f.e}}
	router := gin.New()
	router.GET("/api/runs/:id/workspace/search", h.runWorkspace)
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	req := httptest.NewRequest(http.MethodGet, "/api/runs/"+run.ID+"/workspace/search?q=tracked", nil).WithContext(ctx)
	rec := httptest.NewRecorder()
	router.ServeHTTP(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("cancelled search = %d: %s", rec.Code, rec.Body.String())
	}

	remote := domain.Run{ID: "cvb-r2-workspace-timeout", Status: "running", Nodes: map[string]*domain.NodeRun{},
		ExecutionContext: domain.TelemetryContext{ExecutionMode: domain.ExecutionModeRunner, ExecutionRunnerID: "cvb-timeout"}}
	if err := f.s.PutRun(remote); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutRunner(domain.Runner{ID: "cvb-timeout", Status: domain.RunnerStatusOnline}); err != nil {
		t.Fatal(err)
	}
	hub := newRunnerControlHub()
	hub.conns["cvb-timeout"] = &runnerControlConn{runnerID: "cvb-timeout", send: make(chan runnerControlMessage), done: make(chan struct{})}
	h.runnerControls = hub
	router = gin.New()
	router.GET("/api/runs/:id/workspace", h.runWorkspace)
	expired, stop := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
	defer stop()
	req = httptest.NewRequest(http.MethodGet, "/api/runs/"+remote.ID+"/workspace", nil).WithContext(expired)
	rec = httptest.NewRecorder()
	router.ServeHTTP(rec, req)
	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "超时") {
		t.Fatalf("remote timeout = %d: %s", rec.Code, rec.Body.String())
	}

	searchRoot := t.TempDir()
	longLine := "needle " + strings.Repeat("x", 300)
	cvBWrite(t, filepath.Join(searchRoot, "000.txt"), []byte(longLine))
	for i := 1; i < 83; i++ {
		cvBWrite(t, filepath.Join(searchRoot, fmt.Sprintf("%03d.txt", i)), bytes.Repeat([]byte("z"), 256*1024))
	}
	results, truncated, err := searchWorkspace(context.Background(), searchRoot, "needle")
	if err != nil || !truncated || len(results) != 1 || len([]rune(results[0].Preview)) > 241 {
		t.Fatalf("large search = %#v truncated=%v err=%v", results, truncated, err)
	}
}

// The chat side panel embeds the same IDE on a conversation workspace. Enabling
// edit there must not pause it: Main Bot keeps working beside the person.
func TestConversationWorkspaceIDEEditsWithoutPausing(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	run := domain.Run{ID: "cvb-chat-ws", Kind: domain.RunKindWorkspace, WorkflowID: domain.ConversationWorkspaceWorkflowID, Status: "waiting", ExecutionContext: domain.TelemetryContext{ProjectID: "platform"}, Nodes: map[string]*domain.NodeRun{}}
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	cvBWrite(t, filepath.Join(f.e.RunWorkspace(run.ID), "note.txt"), []byte("old"))

	rec := cvBRequest(t, f, http.MethodGet, "/api/runs/"+run.ID+"/workspace", nil, true)
	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"readOnly":false`) {
		t.Fatalf("workspace info = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+run.ID+"/workspace/takeover", nil, true); rec.Code != http.StatusOK {
		t.Fatalf("takeover = %d: %s", rec.Code, rec.Body.String())
	}
	if got, _ := f.s.RunState(run.ID); got.PauseRequested || got.Status != "waiting" {
		t.Fatalf("takeover paused the conversation workspace: status=%s pause=%v", got.Status, got.PauseRequested)
	}
	sum := sha256.Sum256([]byte("old"))
	body := map[string]any{"path": "note.txt", "content": "new", "expectedSha256": hex.EncodeToString(sum[:])}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+run.ID+"/workspace/file", body, true); rec.Code != http.StatusOK {
		t.Fatalf("write = %d: %s", rec.Code, rec.Body.String())
	}

	cancelled := run
	cancelled.ID, cancelled.CancelRequested = "cvb-chat-ws-cancel", true
	if err := f.s.PutRun(cancelled); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+cancelled.ID+"/workspace/file", body, true); rec.Code == http.StatusOK {
		t.Fatalf("cancelling workspace accepted a write: %s", rec.Body.String())
	}
}

// Like an AI IDE, people edit a running SOP's workspace without pausing it.
func TestRunningSOPWorkspaceEditableWithoutPausing(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	run := domain.Run{ID: "cvb-sop-live", Status: "running", ExecutionContext: domain.TelemetryContext{ProjectID: "platform"}, Nodes: map[string]*domain.NodeRun{"build": {Status: "running"}}}
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	cvBWrite(t, filepath.Join(f.e.RunWorkspace(run.ID), "note.txt"), []byte("old"))
	if rec := cvBRequest(t, f, http.MethodGet, "/api/runs/"+run.ID+"/workspace", nil, true); !strings.Contains(rec.Body.String(), `"readOnly":false`) {
		t.Fatalf("workspace info = %d: %s", rec.Code, rec.Body.String())
	}
	sum := sha256.Sum256([]byte("old"))
	body := map[string]any{"path": "note.txt", "content": "new", "expectedSha256": hex.EncodeToString(sum[:])}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+run.ID+"/workspace/file", body, true); rec.Code != http.StatusOK {
		t.Fatalf("write = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/runs/"+run.ID+"/workspace/file", body, true); rec.Code != http.StatusConflict {
		t.Fatalf("stale write = %d: %s", rec.Code, rec.Body.String())
	}
	if got, _ := f.s.RunState(run.ID); got.PauseRequested || got.Status != "running" {
		t.Fatalf("editing paused the SOP: status=%s pause=%v", got.Status, got.PauseRequested)
	}
	queued := run
	queued.ID, queued.Status, queued.Nodes = "cvb-sop-queued", "queued", map[string]*domain.NodeRun{}
	if err := f.s.PutRun(queued); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/runs/"+queued.ID+"/workspace/takeover", nil, true); rec.Code != http.StatusConflict {
		t.Fatalf("queued takeover = %d: %s", rec.Code, rec.Body.String())
	}
}