relay-flow 0.3.13-alpha → 0.3.14-alpha

package/cmd/relay-flow/startup_alternate_plugins_test.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/server"
+)
+
+func TestServeModesSupportBeadsHerdrPiWithoutReposAndRejectConfiguredConnectionFailures(t *testing.T) {
+	binary := buildCLIBinary(t)
+	for _, failure := range []string{"", "beads", "herdr"} {
+		for _, foreground := range []bool{false, true} {
+			name := failure
+			if name == "" {
+				name = "empty-healthy"
+			}
+			if foreground {
+				name += "-foreground"
+			}
+			t.Run(name, func(t *testing.T) {
+				root := filepath.Join(t.TempDir(), "relay-flow")
+				t.Setenv("RELAY_FLOW_HOME", root)
+				init := exec.Command(binary, "init", "--task-plugin", "beads", "--runner-plugin", "herdr", "--harness-plugin", "pi")
+				if out, err := init.CombinedOutput(); err != nil {
+					t.Fatalf("init: %v\n%s", err, out)
+				}
+				bin := t.TempDir()
+				logPath := filepath.Join(t.TempDir(), "calls")
+				t.Setenv("STARTUP_CALLS", logPath)
+				t.Setenv("HERDR_SESSION", "ambient-session")
+				t.Setenv("HERDR_SOCKET_PATH", "/ambient/socket")
+				t.Setenv("BEADS_DIR", "/ambient/beads")
+				t.Setenv("BEADS_DB", "/ambient/db")
+				p := pathsForRoot(root)
+				cfg, err := config.LoadMachine(p.Config)
+				if err != nil {
+					t.Fatal(err)
+				}
+				cfg.RunnerConfig = config.RawValues{"session": "configured-session", "socketPath": "/configured/socket"}
+				bdScript := "#!/bin/sh\necho 'unexpected ambient workspace read' >&2\nexit 99\n"
+				if failure == "beads" {
+					code, workspace := t.TempDir(), t.TempDir()
+					cfg.Repos = map[string]config.Repo{"app": {Path: code, TaskConfig: config.RawValues{"beadsDir": workspace}}}
+					t.Setenv("EXPECTED_CWD", code)
+					t.Setenv("EXPECTED_BEADS_DIR", workspace)
+					bdScript = `#!/bin/sh
+[ "$*" = 'list --ready --limit 1 --no-parent --json' ] || exit 99
+[ "$PWD" = "$EXPECTED_CWD" ] || exit 98
+[ "$BEADS_DIR" = "$EXPECTED_BEADS_DIR" ] || exit 97
+[ -z "${BEADS_DB+x}" ] || exit 96
+printf '%s\n' 'bd probe' >> "$STARTUP_CALLS"
+printf '%s' 'Dolt connection refused' >&2
+exit 1
+`
+				}
+				herdrScript := `#!/bin/sh
+[ "$*" = 'api snapshot' ] || exit 99
+[ "$HERDR_SESSION" = 'configured-session' ] || exit 98
+[ "$HERDR_SOCKET_PATH" = '/configured/socket' ] || exit 97
+printf '%s\n' 'herdr snapshot' >> "$STARTUP_CALLS"
+`
+				if failure == "herdr" {
+					herdrScript += "printf '%s' '{\"error\":{\"code\":\"connection_refused\",\"message\":\"socket unavailable\"}}' >&2\nexit 1\n"
+				} else {
+					herdrScript += "printf '%s' '{\"result\":{\"snapshot\":{\"workspaces\":[],\"tabs\":[],\"panes\":[]}}}'\n"
+				}
+				for name, script := range map[string]string{"bd": bdScript, "herdr": herdrScript, "pi": "#!/bin/sh\nexit 99\n"} {
+					if err := os.WriteFile(filepath.Join(bin, name), []byte(script), 0o755); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := config.SaveMachine(p.Config, cfg); err != nil {
+					t.Fatal(err)
+				}
+				t.Setenv("PATH", bin)
+				args := []string{"serve"}
+				if foreground {
+					args = append(args, "--foreground")
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+				defer cancel()
+				serve := exec.CommandContext(ctx, binary, args...)
+				if failure != "" {
+					out, err := serve.CombinedOutput()
+					operation := "api snapshot"
+					if failure == "beads" {
+						operation = "Dolt connection refused"
+					}
+					if err == nil || !strings.Contains(string(out), operation) || !strings.Contains(string(out), p.ServerLog) || strings.Contains(string(out), "server started") {
+						t.Fatalf("configured connection failure skipped: %v\n%s", err, out)
+					}
+				} else {
+					client := server.NewClient(p.Socket)
+					if foreground {
+						if err := serve.Start(); err != nil {
+							t.Fatal(err)
+						}
+						wait := make(chan error, 1)
+						go func() { wait <- serve.Wait() }()
+						t.Cleanup(func() { _ = serve.Process.Kill() })
+						waitForServer(t, client)
+						if err := client.Stop(context.Background()); err != nil {
+							t.Fatal(err)
+						}
+						if err := <-wait; err != nil {
+							t.Fatal(err)
+						}
+					} else {
+						if out, err := serve.CombinedOutput(); err != nil || !strings.Contains(string(out), "server started") {
+							t.Fatalf("zero-repo readiness: %v\n%s", err, out)
+						}
+						if err := client.Stop(context.Background()); err != nil {
+							t.Fatal(err)
+						}
+					}
+					waitForServerStop(t, client)
+					if log := readFile(t, p.ServerLog); !strings.Contains(log, "deferred to registration") {
+						t.Fatalf("unconfigured Beads connection not reported deferred: %s", log)
+					}
+				}
+				wantCalls := "herdr snapshot\n"
+				if failure == "beads" {
+					wantCalls = "bd probe\n"
+				}
+				if calls := readFile(t, logPath); calls != wantCalls {
+					t.Fatalf("unselected/duplicate/full-discovery startup calls: %q", calls)
+				}
+			})
+		}
+	}
+}

package/cmd/relay-flow/startup_errors.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// Both foreground and the in-process CLI seam write the same owned record.
+// PID lets the detached parent distinguish its child from a racing lock owner.
+func logStartupFailure(err error) {
+	slog.Error("server startup failed", "pid", os.Getpid(), "error", startupDiagnostic(err.Error()))
+}
+
+func startupLogOffset(path string) int64 {
+	info, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return 0
+	}
+	if err != nil {
+		return -1 // Cannot establish this attempt's boundary: do not replay logs.
+	}
+	return info.Size()
+}
+
+// readStartupFailure reads only this attempt's bounded tail, and only the
+// selected child's owned startup-failure record. All other log content stays
+// in server.log. Missing/truncated/unreadable records leave the normal exit
+// diagnostic and log location intact, never substitute an older error.
+func readStartupFailure(path string, offset int64, pid int) string {
+	if offset < 0 || pid <= 0 {
+		return ""
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		return ""
+	}
+	defer f.Close()
+	info, err := f.Stat()
+	if err != nil || info.Size() <= offset {
+		return ""
+	}
+	const maxDiagnosticBytes int64 = 64 << 10
+	start := max(offset, info.Size()-maxDiagnosticBytes)
+	if _, err := f.Seek(start, io.SeekStart); err != nil {
+		return ""
+	}
+	data, err := io.ReadAll(io.LimitReader(f, maxDiagnosticBytes))
+	if err != nil {
+		return ""
+	}
+	// logging.Setup owns this text-handler record and its field order.
+	marker := fmt.Sprintf(`msg="server startup failed" pid=%d error=`, pid)
+	lines := strings.Split(string(data), "\n")
+	for i := len(lines) - 1; i >= 0; i-- {
+		index := strings.Index(lines[i], marker)
+		if index < 0 {
+			continue
+		}
+		value := strings.TrimSpace(lines[i][index+len(marker):])
+		if strings.HasPrefix(value, `"`) {
+			value, err = strconv.Unquote(value)
+			if err != nil {
+				return ""
+			}
+		}
+		return startupDiagnostic(value)
+	}
+	return ""
+}
+
+// Credential redaction belongs to the adapter. This final display step keeps
+// external control characters out of both foreground and detached caller TUIs.
+func startupDiagnostic(message string) string {
+	return strings.Map(func(r rune) rune {
+		if unicode.IsControl(r) {
+			return ' '
+		}
+		return r
+	}, message)
+}

package/cmd/relay-flow/startup_errors_test.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestStartupDiagnosticReadsOnlyCurrentAttemptAndChild(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "server.log")
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	log := slog.New(slog.NewTextHandler(file, nil))
+	log.Error("server startup failed", "pid", 123, "error", errors.New("stale same-pid error"))
+	offset := startupLogOffset(path)
+	log.Error("server startup failed", "pid", 456, "error", errors.New("another child's error"))
+	log.Warn("unrelated warning", "error", "private warning payload")
+	if got := readStartupFailure(path, offset, 123); got != "" {
+		t.Fatalf("replayed stale or unrelated diagnostic: %q", got)
+	}
+	failure := `startup prerequisite runner plugin "orca": orca repo list: connection refused`
+	log.Error("server startup failed", "pid", 123, "error", errors.New(failure))
+	if got := readStartupFailure(path, offset, 123); got != failure {
+		t.Fatalf("current child diagnostic = %q, want %q", got, failure)
+	}
+	if got := readStartupFailure(path, offset, 12); got != "" {
+		t.Fatalf("PID prefix matched another child: %q", got)
+	}
+}
+
+func TestStartupDiagnosticIsBoundedAndDoesNotReplayTruncatedOrUnreadableLogs(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "server.log")
+	old := fmt.Sprintf("msg=\"server startup failed\" pid=123 error=%q\n", "stale error")
+	if err := os.WriteFile(path, []byte(old+strings.Repeat("unrelated log data\n", 10000)), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if got := readStartupFailure(path, 0, 123); got != "" {
+		t.Fatalf("reader scanned beyond bounded tail: %q", got)
+	}
+	offset := startupLogOffset(path)
+	if err := os.WriteFile(path, []byte(old), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if got := readStartupFailure(path, offset, 123); got != "" {
+		t.Fatalf("replayed truncated log: %q", got)
+	}
+	for _, offset := range []int64{-1, 1000} {
+		if got := readStartupFailure(path, offset, 123); got != "" {
+			t.Fatalf("invalid boundary replayed old error: %q", got)
+		}
+	}
+	if got := readStartupFailure(path+"-absent", 0, 123); got != "" {
+		t.Fatalf("missing log returned diagnostic: %q", got)
+	}
+}
+
+func TestStartupDiagnosticRemovesTerminalControlCharacters(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "server.log")
+	line := fmt.Sprintf("msg=\"server startup failed\" pid=123 error=%q\n", "orca repo list: \x1b[31mconnection\nrefused")
+	if err := os.WriteFile(path, []byte(line), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	got := readStartupFailure(path, 0, 123)
+	if strings.ContainsAny(got, "\x1b\n\r") || !strings.Contains(got, "connection refused") {
+		t.Fatalf("unsafe diagnostic: %q", got)
+	}
+}
+
+func TestGuidedStartupPropagatesInProcessFailureAndWritesOwnedLogRecord(t *testing.T) {
+	failure := errors.New("task connection refused")
+	f := newPrerequisiteFixture(t, func(context.Context) error { return failure })
+	err := ensureFirstRunServer(f.paths)
+	if err == nil || !strings.Contains(err.Error(), "task connection refused") || !strings.Contains(err.Error(), f.cfg.TaskPlugin) || !strings.Contains(err.Error(), f.paths.ServerLog) {
+		t.Fatalf("guided startup lost dependency or log location: %v", err)
+	}
+	got := readStartupFailure(f.paths.ServerLog, 0, os.Getpid())
+	if !strings.Contains(got, "startup prerequisite task plugin") || !strings.Contains(got, "task connection refused") {
+		t.Fatalf("in-process startup did not write owned failure record: %q", got)
+	}
+}

package/cmd/relay-flow/startup_failure_categories_test.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/server"
+)
+
+func TestServeModesPropagateDependencyFailureCategoriesWithoutRetries(t *testing.T) {
+	binary := buildCLIBinary(t)
+	for _, tc := range []struct {
+		name, stage, script, want string
+		status                    int
+		body                      string
+	}{
+		{name: "runner-launch", stage: "runner", script: "#!/nonexistent/interpreter\n", want: "launch failure"},
+		{name: "runner-connection", stage: "runner", script: "#!/bin/sh\nprintf '%s' 'runtime connection refused' >&2\nexit 1\n", want: "connection refused"},
+		{name: "runner-malformed", stage: "runner", script: "#!/bin/sh\nprintf '%s' '{\"result\":{}}'\n", want: "malformed response"},
+		{name: "runner-timeout", stage: "runner", script: "#!/bin/sh\nexec /bin/sleep 30\n", want: "timeout"},
+		{name: "task-authentication", stage: "task", status: 401, body: "fixture-token startup@example.invalid", want: "authentication"},
+		{name: "task-connection", stage: "task", status: 503, body: "service unavailable", want: "HTTP 503"},
+		{name: "task-malformed", stage: "task", status: 200, body: "not-json", want: "malformed response"},
+		{name: "task-timeout", stage: "task", status: 0, want: "timeout"},
+	} {
+		for _, foreground := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/foreground=%v", tc.name, foreground), func(t *testing.T) {
+				root := filepath.Join(t.TempDir(), "relay-flow")
+				t.Setenv("RELAY_FLOW_HOME", root)
+				init := exec.Command(binary, initArgs()...)
+				init.Env = os.Environ()
+				if out, err := init.CombinedOutput(); err != nil {
+					t.Fatalf("init: %v\n%s", err, out)
+				}
+				installHealthyServePrerequisites(t, root)
+				bin := strings.Split(os.Getenv("PATH"), string(os.PathListSeparator))[0]
+				t.Setenv("PATH", bin)
+				var calls atomic.Int32
+				operation := "repo list"
+				if tc.stage == "runner" {
+					launcher := "orca"
+					if runtime.GOOS == "linux" {
+						launcher = "orca-ide"
+					}
+					if err := os.WriteFile(filepath.Join(bin, launcher), []byte(tc.script), 0o755); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					operation = "/rest/api/3/myself"
+					s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+						calls.Add(1)
+						user, token, ok := r.BasicAuth()
+						if !ok || user != "startup@example.invalid" || token != "fixture-token" || r.Method != "GET" || r.URL.Path != "/rest/api/3/myself" {
+							t.Errorf("unexpected probe: %s %s", r.Method, r.URL.Path)
+						}
+						if tc.status == 0 {
+							<-r.Context().Done()
+							return
+						}
+						w.Header().Set("Retry-After", "60")
+						w.WriteHeader(tc.status)
+						_, _ = w.Write([]byte(tc.body))
+					}))
+					t.Cleanup(s.Close)
+					credentials := fmt.Sprintf("site: %q\nemail: startup@example.invalid\ntoken: fixture-token\n", s.URL)
+					if err := os.WriteFile(filepath.Join(root, "credentials.yaml"), []byte(credentials), 0o600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				// An earlier run's record must never escape into this diagnostic.
+				logPath := filepath.Join(root, "server.log")
+				if err := os.WriteFile(logPath, []byte("msg=\"server startup failed\" pid=1 error=\"STALE_PRIVATE_ERROR\"\n"), 0o600); err != nil {
+					t.Fatal(err)
+				}
+				args := []string{"serve"}
+				if foreground {
+					args = append(args, "--foreground")
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+				defer cancel()
+				serve := exec.CommandContext(ctx, binary, args...)
+				serve.Env = os.Environ()
+				start := time.Now()
+				out, err := serve.CombinedOutput()
+				if err == nil || strings.Contains(string(out), "server started") || !strings.Contains(string(out), tc.want) || !strings.Contains(string(out), operation) || !strings.Contains(string(out), logPath) {
+					t.Fatalf("failure category or safe identity lost: err=%v, output=%s", err, out)
+				}
+				for _, secret := range []string{"fixture-token", "startup@example.invalid", "STALE_PRIVATE_ERROR"} {
+					if strings.Contains(string(out), secret) {
+						t.Fatalf("startup diagnostic exposed secret/stale record %q: %s", secret, out)
+					}
+				}
+				if tc.stage == "task" && calls.Load() != 1 {
+					t.Fatalf("credential probe retried or queried project data: %d calls", calls.Load())
+				}
+				if elapsed := time.Since(start); elapsed > 7*time.Second {
+					t.Fatalf("startup probe inherited retries or exceeded ceiling: %v", elapsed)
+				}
+				if serverResponding(server.NewClient(filepath.Join(root, "server.sock")), 50*time.Millisecond) {
+					t.Fatal("failed probe left ready server")
+				}
+			})
+		}
+	}
+}

package/cmd/relay-flow/startup_ordering_test.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/server"
+)
+
+func TestServeDoesNotOpenExecutionStateOrPublishReadinessWhileProbeIsPending(t *testing.T) {
+	f := newPrerequisiteFixture(t, nil)
+	entered, release := make(chan struct{}), make(chan struct{})
+	f.hrn.probe = func(ctx context.Context) error {
+		close(entered)
+		select {
+		case <-release:
+			return nil
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+	before, err := os.ReadFile(f.paths.Database)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan error, 1)
+	go func() { done <- serveRoot(ctx, f.paths, false) }()
+	finished := false
+	t.Cleanup(func() {
+		cancel()
+		if !finished {
+			select {
+			case <-done:
+			case <-time.After(10 * time.Second):
+				t.Error("serveRoot did not stop")
+			}
+		}
+	})
+	select {
+	case <-entered:
+	case err := <-done:
+		finished = true
+		t.Fatalf("server exited before probe: %v", err)
+	case <-time.After(time.Second):
+		t.Fatal("startup probe did not begin")
+	}
+	client := server.NewClient(f.paths.Socket)
+	if serverResponding(client, 100*time.Millisecond) {
+		t.Fatal("pending prerequisite was mistaken for readiness")
+	}
+	if _, err := os.Stat(f.paths.Socket); !os.IsNotExist(err) {
+		t.Fatalf("socket opened before prerequisite completion: %v", err)
+	}
+	after, err := os.ReadFile(f.paths.Database)
+	if err != nil || string(after) != string(before) {
+		t.Fatalf("execution state opened/migrated before prerequisites: %v", err)
+	}
+	close(release)
+	waitForServerOrError(t, client, done)
+	if err := client.Stop(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case err := <-done:
+		finished = true
+		if err != nil {
+			t.Fatal(err)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("ready server did not stop")
+	}
+}