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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package httpapi
import (
"context"
"crypto/sha256"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
stdsync "sync"
"testing"
"time"
"agentflow/internal/domain"
"agentflow/internal/engine"
"agentflow/internal/repo"
"agentflow/internal/runtime"
"github.com/gin-gonic/gin"
)
func TestStreamRunLargeDeltasCancellationAndMissing(t *testing.T) {
gin.SetMode(gin.TestMode)
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
telemetry := make([]domain.TelemetryEvent, 100)
logs := make([]domain.LogRecord, 100)
for i := range telemetry {
seq := int64(i + 1)
telemetry[i] = domain.TelemetryEvent{ID: "telemetry", Sequence: seq, Message: "event"}
logs[i] = domain.LogRecord{ID: "log", Sequence: seq, Body: "record"}
}
run := domain.Run{
ID: "cvb-stream", WorkflowID: "generic-code", Status: "running", Revision: 7,
Telemetry: telemetry, TelemetrySequence: 100, Logs: logs, LogSequence: 100,
}
if err := st.PutRun(run); err != nil {
t.Fatal(err)
}
e := engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces")))
h := &streamHandlers{deps: &deps{repo: st, engine: e}}
router := gin.New()
router.GET("/runs/:id", h.streamRun)
server := httptest.NewServer(router)
t.Cleanup(server.Close)
ctx, cancel := context.WithCancel(context.Background())
req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/runs/cvb-stream?after=0&logsAfter=0", nil)
if err != nil {
t.Fatal(err)
}
resp, err := server.Client().Do(req)
if err != nil {
t.Fatal(err)
}
body := make(chan string, 1)
go func() {
raw, _ := io.ReadAll(resp.Body)
body <- string(raw)
}()
cancel()
var raw string
select {
case raw = <-body:
case <-time.After(10 * time.Second):
t.Fatal("stream did not stop after request cancellation")
}
_ = resp.Body.Close()
if !strings.Contains(raw, "event: run") || strings.Count(raw, `"sequence"`) == 0 {
t.Fatalf("expected telemetry and log deltas, got %d sequences", strings.Count(raw, `"sequence"`))
}
missing := httptest.NewRecorder()
router.ServeHTTP(missing, httptest.NewRequest(http.MethodGet, "/runs/not-found", nil))
if missing.Code != http.StatusNotFound {
t.Fatalf("missing run status = %d", missing.Code)
}
}
func TestStreamRunHeartbeat(t *testing.T) {
gin.SetMode(gin.TestMode)
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
if err := st.PutRun(domain.Run{ID: "cvb-heartbeat", WorkflowID: "generic-code", Status: "running"}); err != nil {
t.Fatal(err)
}
e := engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces")))
h := &streamHandlers{deps: &deps{repo: st, engine: e}}
router := gin.New()
router.GET("/runs/:id", h.streamRun)
server := httptest.NewServer(router)
t.Cleanup(server.Close)
ctx, cancel := context.WithTimeout(context.Background(), 17*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/runs/cvb-heartbeat", nil)
if err != nil {
t.Fatal(err)
}
resp, err := server.Client().Do(req)
if err != nil {
t.Fatal(err)
}
raw, _ := io.ReadAll(resp.Body)
_ = resp.Body.Close()
if !strings.Contains(string(raw), ": heartbeat") {
t.Fatalf("heartbeat missing from %q", raw)
}
}
func TestStreamFilesystemResolutionBranches(t *testing.T) {
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("PATH", t.TempDir())
t.Setenv("AGENTFLOW_CODEBUDDY_BIN", filepath.Join(home, "missing-override"))
t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", "")
bin := filepath.Join(home, ".local", "bin", "codebuddy")
if err := os.MkdirAll(filepath.Dir(bin), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(bin, []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
t.Fatal(err)
}
if got, err := resolveCodeBuddyBin(); err != nil || got != bin {
t.Fatalf("fallback binary = %q, %v", got, err)
}
if !fileExecutable(bin) || fileExecutable(filepath.Dir(bin)) || fileExecutable(filepath.Join(home, "absent")) {
t.Fatal("fileExecutable classification failed")
}
if err := os.Chmod(bin, 0o644); err != nil {
t.Fatal(err)
}
_, _ = resolveCodeBuddyBin()
if got := clarifyRepoCacheRoot(); !strings.HasPrefix(got, home) {
t.Fatalf("cache root = %q", got)
}
if got := sanitizeDirName(" .. ", "fallback"); got != "fallback" {
t.Fatalf("sanitize fallback = %q", got)
}
if got := stripGitCLINoise("\x1b[31m fatal: bad \x1b[0m"); got != "fatal: bad" {
t.Fatalf("noise stripping = %q", got)
}
t.Setenv("HOME", " ")
if got := clarifyRepoCacheRoot(); got != "/root/.agentflow/clarify-cache" {
t.Fatalf("blank-home cache root = %q", got)
}
got, err := resolveCodeBuddyBin()
if err == nil && got != "/usr/local/bin/codebuddy" && got != "/usr/bin/codebuddy" && got != "/root/.local/bin/codebuddy" {
t.Fatalf("blank-home system binary = %q, %v", got, err)
}
}
func TestStreamRepositorySourceAndLocks(t *testing.T) {
plain := t.TempDir()
repository := domain.Repository{ID: "r", LocalPath: plain}
got, snapshot := clarifyRepositorySource(repository, "")
if !snapshot || got.LocalPath != plain {
t.Fatalf("plain source = %+v, snapshot=%v", got, snapshot)
}
repository.CloneURL = "https://example.invalid/repo.git"
if _, snapshot := clarifyRepositorySource(repository, "main"); snapshot {
t.Fatal("branched plain directory used as a snapshot")
}
repository.LocalPath = filepath.Join(plain, "missing")
if _, snapshot := clarifyRepositorySource(repository, ""); snapshot {
t.Fatal("missing local directory used as a snapshot")
}
h := &streamHandlers{}
first := h.repoLock("same")
if first != h.repoLock("same") || first == h.repoLock("other") {
t.Fatal("repository mutexes are not stable per repository")
}
if statDir(filepath.Join(plain, "missing")) || !statDir(plain) {
t.Fatal("statDir classification failed")
}
}
func TestStreamPrepareRepositoryStaleDefaultCheckout(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
home := t.TempDir()
t.Setenv("HOME", home)
repository := domain.Repository{ID: "cvb-stale", Name: "stale", CloneURL: filepath.Join(home, "missing-source")}
identityDir := sanitizeDirName(repository.Name, repository.ID)
h := &streamHandlers{deps: &deps{repo: st}}
// Create the same cache layout through the production hash expression.
hashInput := repository.ID + "\x00master"
identity := sha256.Sum256([]byte(hashInput))
sum := fmt.Sprintf("%x", identity[:8])
cache := filepath.Join(clarifyRepoCacheRoot(), identityDir+"-"+sum)
if err := os.MkdirAll(filepath.Join(cache, ".git"), 0o755); err != nil {
t.Fatal(err)
}
dir, analyzed, reason := h.prepareClarifyRepo(context.Background(), repository, "", 1, true)
if !analyzed || dir != cache || reason != "" {
t.Fatalf("stale default checkout = %q, %v, %q", dir, analyzed, reason)
}
}
func TestStreamProtocolRemainingBranches(t *testing.T) {
if got := clarifyStreamEvents("{"); got != nil {
t.Fatalf("invalid stream event = %#v", got)
}
if got := clarifyStreamEvents(`{"type":"result"}`); got != nil {
t.Fatalf("non-assistant stream event = %#v", got)
}
line := `{"type":"assistant","message":{"content":[` +
`{"type":"thinking","thinking":" useful thought "},` +
`{"type":"thinking","thinking":"{\"summary\":\"hidden\",\"questions\":[]}"},` +
`{"type":"text","text":" visible text "},` +
`{"type":"tool_use","name":"Grep","input":{"pattern":"needle"}}]}}`
if got := clarifyStreamEvents(line); len(got) != 3 || got[2]["detail"] != "needle" {
t.Fatalf("stream events = %#v", got)
}
if extractClarifyProtocolObject("{broken}") != nil {
t.Fatal("broken protocol object accepted")
}
if got := clarifyToolDetail("none", json.RawMessage(`{"pattern":"p"}`)); got != "p" {
t.Fatalf("pattern-only detail = %q", got)
}
if got := clarifyToolDetail(mainBotBrowserPrefix+"press", json.RawMessage(`{"ref":"r","text":"label"}`)); got != "r ← label" {
t.Fatalf("browser ref detail = %q", got)
}
if got := clarifyToolDetail(mainBotBrowserPrefix+"press", json.RawMessage(`{"ref":"r"}`)); got != "r" {
t.Fatalf("browser bare ref detail = %q", got)
}
protocol := `{"summary":"ok","questions":[]}`
resultWithEventContent := `{"type":"result","content":[{"text":"` + strings.ReplaceAll(protocol, `"`, `\"`) + `"}]}`
if value, _ := extractClarifyResultJSON(resultWithEventContent); value == nil {
t.Fatal("result event content was not extracted")
}
assistantEnvelope := map[string]any{"type": "assistant", "message": map[string]any{
"content": []any{map[string]any{"text": protocol}},
}}
if value, ok := unwrapStreamJSONEnvelope(assistantEnvelope); !ok || value == nil {
t.Fatalf("assistant envelope = %#v, %v", value, ok)
}
for _, raw := range []string{
"\nnot-json\n" + protocol,
protocol + "\n\n" + protocol,
`{"type":"result","result":"plain result"}`,
`{"type":"result","result":{"type":"result","result":{"summary":"nested"}}}`,
`{"message":{"content":[null,{"content":"` + strings.ReplaceAll(protocol, `"`, `\"`) + `"}]}}`,
`{"message":{"content":[{"text":"` + strings.ReplaceAll(protocol, `"`, `\"`) + `"}]}}` + "\ntrailer",
`{"content":[],"text":"` + strings.ReplaceAll(protocol, `"`, `\"`) + `"}`,
} {
if value, returned := extractJSONObject(raw); value == nil || returned == "" {
t.Errorf("extractJSONObject(%q) = %#v, %q", raw, value, returned)
}
}
if value, ok := unwrapStreamJSONEnvelope(map[string]any{"type": "result", "result": "without json"}); !ok || value == nil {
t.Fatalf("non-JSON result envelope = %#v, %v", value, ok)
}
if value, ok := unwrapStreamJSONEnvelope(map[string]any{"type": "result", "result": "prefix {broken} suffix"}); !ok || value == nil {
t.Fatalf("broken inner result envelope = %#v, %v", value, ok)
}
fallbackRaw := `{"type":"assistant","message":{"content":[{"text":"` + strings.ReplaceAll(protocol, `"`, `\"`) + `"}]}}` + "\n" + `{"other":1}`
if value, raw := extractJSONObject(fallbackRaw); value == nil || raw == "" {
t.Fatalf("fallback object = %#v, %q", value, raw)
}
brokenAssistant := map[string]any{"type": "assistant", "message": map[string]any{
"content": []any{map[string]any{"text": "{broken}"}},
}}
if value, ok := unwrapStreamJSONEnvelope(brokenAssistant); !ok || value == nil {
t.Fatalf("broken assistant envelope = %#v, %v", value, ok)
}
try := func(string) (any, bool) { return nil, false }
if _, _, ok := extractClarifyJSONFromEvent(map[string]any{"content": []any{nil}}, try); ok {
t.Fatal("nil content unexpectedly extracted")
}
}
func TestStreamChatClarifyValidationBranches(t *testing.T) {
gin.SetMode(gin.TestMode)
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
if err := st.PutProject(domain.Project{ID: "cvb-other-project", Name: "Other"}); err != nil {
t.Fatal(err)
}
if err := st.PutRepository(domain.Repository{ID: "cvb-foreign", ProjectID: "cvb-other-project", Name: "Foreign"}); err != nil {
t.Fatal(err)
}
h := &streamHandlers{deps: &deps{repo: st}}
router := gin.New()
router.POST("/clarify", h.chatClarify)
cases := []struct {
name, body string
}{
{"malformed", "{"},
{"missing project", `{"message":"x"}`},
{"unknown project", `{"projectId":"does-not-exist","message":"x"}`},
{"foreign repository", `{"projectId":"platform","repositoryId":"cvb-foreign","baseBranch":"main","message":"x"}`},
}
for _, tc := range cases {
rec := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/clarify", strings.NewReader(tc.body))
req.Header.Set("Content-Type", "application/json")
router.ServeHTTP(rec, req)
if rec.Code != http.StatusBadRequest {
t.Errorf("%s status = %d: %s", tc.name, rec.Code, rec.Body.String())
}
}
}
func TestStreamCancelAllAndSpecificJobs(t *testing.T) {
gin.SetMode(gin.TestMode)
legacyCtx, legacyCancel := context.WithCancel(context.Background())
composerCtx, composerCancel := context.WithCancel(context.Background())
specificCtx, specificCancel := context.WithCancel(context.Background())
h := &streamHandlers{
clarifyCancels: map[string]context.CancelFunc{"legacy": legacyCancel},
jobs: &clarifyHub{jobs: map[string]*clarifyJob{
"composer:all": {issueID: "composer:all", cancel: composerCancel, done: make(chan struct{})},
"composer:one": {issueID: "composer:one", cancel: specificCancel, done: make(chan struct{})},
}},
}
router := gin.New()
router.POST("/cancel", h.chatClarifyCancel)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/cancel?jobId=one", strings.NewReader("{}")))
if rec.Code != http.StatusOK {
t.Fatalf("specific cancel status = %d", rec.Code)
}
select {
case <-specificCtx.Done():
default:
t.Fatal("specific composer job was not cancelled")
}
select {
case <-legacyCtx.Done():
t.Fatal("specific cancellation cancelled legacy jobs")
default:
}
rec = httptest.NewRecorder()
router.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/cancel", nil))
if rec.Code != http.StatusOK {
t.Fatalf("cancel-all status = %d", rec.Code)
}
for name, ctx := range map[string]context.Context{"legacy": legacyCtx, "composer": composerCtx} {
select {
case <-ctx.Done():
default:
t.Errorf("%s context was not cancelled", name)
}
}
}
func TestStreamExecuteWithMixedRepositoryAvailability(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
user := domain.User{ID: 881, LoginName: "cvb-mixed", ChineseName: "cvB mixed", CodeBuddyAPIKey: "cvb-test-key"}
if err := st.PutUser(user); err != nil {
t.Fatal(err)
}
root := t.TempDir()
t.Setenv("HOME", root)
t.Setenv("AGENTFLOW_CLARIFY_SESSION_DIR", filepath.Join(root, "sessions"))
bin := filepath.Join(root, "codebuddy")
t.Setenv("AGENTFLOW_CODEBUDDY_BIN", bin)
script := "#!/bin/sh\nprintf '%s\\n' '{\"type\":\"result\",\"result\":\"{\\\"summary\\\":\\\"ok\\\",\\\"ready\\\":true,\\\"questions\\\":[]}\"}'\n"
if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
t.Fatal(err)
}
local := filepath.Join(root, "source")
if err := os.Mkdir(local, 0o755); err != nil {
t.Fatal(err)
}
repositories := []domain.Repository{
{ID: "cvb-local", ProjectID: "platform", Name: "local", LocalPath: local},
{ID: "cvb-inaccessible", ProjectID: "platform", Name: "inaccessible", LocalPath: filepath.Join(root, "missing")},
{ID: "cvb-unconfigured", ProjectID: "platform", Name: "unconfigured"},
}
for _, repository := range repositories {
if err := st.PutRepository(repository); err != nil {
t.Fatal(err)
}
}
h := &streamHandlers{deps: &deps{repo: st}}
issue := domain.Issue{
ProjectID: "platform", AssigneeUserID: user.ID, Title: "mixed repositories", Description: "test",
RepositoryIDs: []string{"missing-repository", "cvb-local", "cvb-inaccessible", "cvb-unconfigured"},
}
events := make([]string, 0)
var mu stdsync.Mutex
emit := func(event string, _ any) {
mu.Lock()
events = append(events, event)
mu.Unlock()
}
request := chatClarifyRequest{}
request.History = append(request.History, struct {
Role string `json:"role"`
Content string `json:"content"`
}{Role: "assistant", Content: strings.Repeat("history", 700)})
parsed, _, info, err := h.executeClarify(context.Background(), issue, request, emit)
if err != nil || parsed == nil || info["analyzed"] != false {
t.Fatalf("mixed repository clarify = %#v, %#v, %v", parsed, info, err)
}
if len(events) == 0 {
t.Fatal("clarification emitted no progress")
}
}
func TestStreamExecuteEarlyErrorsAndMultiRepositoryPrompt(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
user := domain.User{ID: 882, LoginName: "cvb-multi", ChineseName: "cvB multi", CodeBuddyAPIKey: "cvb-test-key"}
if err := st.PutUser(user); err != nil {
t.Fatal(err)
}
h := &streamHandlers{deps: &deps{repo: st}}
if _, _, _, err := h.executeClarify(context.Background(), domain.Issue{
ProjectID: "platform", AssigneeUserID: 999999,
}, chatClarifyRequest{}, nil); err == nil {
t.Fatal("invalid responsible user unexpectedly succeeded")
}
root := t.TempDir()
t.Setenv("HOME", root)
t.Setenv("AGENTFLOW_CLARIFY_SESSION_DIR", filepath.Join(root, "sessions"))
t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", filepath.Join(root, "missing-inventory"))
if _, _, _, err := h.executeClarify(context.Background(), domain.Issue{
ProjectID: "platform", AssigneeUserID: user.ID, Kind: "issue", Title: "bug", Description: "broken",
}, chatClarifyRequest{}, nil); err == nil {
t.Fatal("missing managed inventory unexpectedly succeeded")
}
t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", "")
bin := filepath.Join(root, "codebuddy")
t.Setenv("AGENTFLOW_CODEBUDDY_BIN", bin)
script := "#!/bin/sh\nprintf '%s\\n' '{\"type\":\"result\",\"result\":\"{\\\"summary\\\":\\\"ok\\\",\\\"ready\\\":true,\\\"questions\\\":[]}\"}'\n"
if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
t.Fatal(err)
}
for _, id := range []string{"cvb-multi-a", "cvb-multi-b"} {
dir := filepath.Join(root, id)
if err := os.Mkdir(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := st.PutRepository(domain.Repository{
ID: id, ProjectID: "platform", Name: "duplicate name", LocalPath: dir,
}); err != nil {
t.Fatal(err)
}
}
issue := domain.Issue{
ProjectID: "platform", AssigneeUserID: user.ID, Kind: "issue", Title: "bug", Description: "broken",
RepositoryIDs: []string{"cvb-multi-a", "cvb-multi-b", "cvb-multi-missing"},
}
if parsed, _, _, err := h.executeClarify(context.Background(), issue, chatClarifyRequest{}, nil); err != nil || parsed == nil {
t.Fatalf("multi repository clarify = %#v, %v", parsed, err)
}
}
func TestStreamExecuteDirectorySessionAndTerminalErrors(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
user := domain.User{ID: 883, LoginName: "cvb-errors", ChineseName: "cvB errors", CodeBuddyAPIKey: "cvb-test-key"}
if err := st.PutUser(user); err != nil {
t.Fatal(err)
}
h := &streamHandlers{deps: &deps{repo: st}}
issue := domain.Issue{ProjectID: "platform", AssigneeUserID: user.ID, Title: "errors"}
blockedBase := filepath.Join(t.TempDir(), "sessions")
if err := os.MkdirAll(filepath.Dir(blockedBase), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(blockedBase, []byte("file"), 0o644); err != nil {
t.Fatal(err)
}
t.Setenv("AGENTFLOW_CLARIFY_SESSION_DIR", blockedBase)
if _, _, _, err := h.executeClarify(context.Background(), issue, chatClarifyRequest{}, nil); err == nil {
t.Fatal("blocked session base unexpectedly succeeded")
}
sessionBase := filepath.Join(t.TempDir(), "sessions")
t.Setenv("AGENTFLOW_CLARIFY_SESSION_DIR", sessionBase)
mcpSessions := filepath.Join(clarifyCLIHome(user.ID), "mcp-sessions")
if err := os.MkdirAll(filepath.Dir(mcpSessions), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(mcpSessions, []byte("file"), 0o644); err != nil {
t.Fatal(err)
}
if _, _, _, err := h.executeClarify(context.Background(), issue, chatClarifyRequest{}, nil); err == nil {
t.Fatal("blocked MCP session directory unexpectedly succeeded")
}
if err := os.Remove(mcpSessions); err != nil {
t.Fatal(err)
}
bin := filepath.Join(t.TempDir(), "codebuddy")
if err := os.WriteFile(bin, []byte("#!/bin/sh\nprintf '%s\\n' 'no terminal object'\n"), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("AGENTFLOW_CODEBUDDY_BIN", bin)
if _, _, _, err := h.executeClarify(context.Background(), issue, chatClarifyRequest{}, nil); err == nil {
t.Fatal("missing terminal clarification unexpectedly succeeded")
}
for _, id := range []string{"cvb-ws-a", "cvb-ws-b"} {
dir := filepath.Join(t.TempDir(), id)
if err := os.Mkdir(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := st.PutRepository(domain.Repository{ID: id, ProjectID: "platform", Name: id, LocalPath: dir}); err != nil {
t.Fatal(err)
}
}
blockedWorkspaceIssue := issue
blockedWorkspaceIssue.ID = "cvb-blocked-workspace"
blockedWorkspaceIssue.RepositoryIDs = []string{"cvb-ws-a", "cvb-ws-b"}
blockedWorkspace := clarifyWorkspaceDir(user.ID, blockedWorkspaceIssue.ID)
if err := os.MkdirAll(filepath.Dir(blockedWorkspace), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(blockedWorkspace, []byte("file"), 0o644); err != nil {
t.Fatal(err)
}
_, _, _, _ = h.executeClarify(context.Background(), blockedWorkspaceIssue, chatClarifyRequest{}, nil)
blockedEmptyIssue := issue
blockedEmptyIssue.ID = "cvb-blocked-empty"
blockedEmpty := clarifyWorkspaceDir(user.ID, blockedEmptyIssue.ID+"-empty")
if err := os.MkdirAll(filepath.Dir(blockedEmpty), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(blockedEmpty, []byte("file"), 0o644); err != nil {
t.Fatal(err)
}
_, _, _, _ = h.executeClarify(context.Background(), blockedEmptyIssue, chatClarifyRequest{}, nil)
if err := os.WriteFile(bin, []byte("#!/bin/sh\nexit 9\n"), 0o755); err != nil {
t.Fatal(err)
}
if _, _, _, err := h.executeClarify(context.Background(), issue, chatClarifyRequest{}, nil); err == nil {
t.Fatal("failed clarify command unexpectedly succeeded")
}
var nilHandler *streamHandlers
nilHandler.rememberClarifySession("issue", "session", user.ID)
}
func TestStreamRunClarifyTurnOutputAndFailure(t *testing.T) {
root := t.TempDir()
success := filepath.Join(root, "success")
successScript := `#!/bin/sh
printf '%s\n' 'plain output'
printf '%s\n' '{"type":"assistant","session_id":"captured-session","message":{"content":[{"type":"thinking","thinking":"working"}]}}'
`
if err := os.WriteFile(success, []byte(successScript), 0o755); err != nil {
t.Fatal(err)
}
var emitted []any
h := &streamHandlers{}
_, raw, captured, err := h.runClarifyTurn(
context.Background(), root, success, "claude-sonnet-4", "prompt", "run",
"initial", "", false, runtime.RunCredentials{CodeBuddy: runtime.CodeBuddyCredential{APIKey: "cvb-test-key"}},
func(_ string, payload any) { emitted = append(emitted, payload) }, clarifyTurnOpts{Native: true},
)
if err != nil || !strings.Contains(raw, "plain output") || captured != "captured-session" || len(emitted) == 0 {
t.Fatalf("successful turn = %q, %q, %#v, %v", raw, captured, emitted, err)
}
failure := filepath.Join(root, "failure")
if err := os.WriteFile(failure, []byte("#!/bin/sh\nexit 7\n"), 0o755); err != nil {
t.Fatal(err)
}
if _, _, _, err := h.runClarifyTurn(
context.Background(), root, failure, "claude-sonnet-4", "prompt", "run",
"session", "", false, runtime.RunCredentials{CodeBuddy: runtime.CodeBuddyCredential{APIKey: "cvb-test-key"}}, nil, clarifyTurnOpts{Native: true},
); err == nil {
t.Fatal("failed command unexpectedly succeeded")
}
}