relay-flow 0.0.1 → 0.2.0-alpha

package/internal/execution/goworkflows/retry_log_test.go

@@ -0,0 +1,59 @@
+package goworkflows
+
+import (
+	"strings"
+	"testing"
+)
+
+// 9.6: the info-level retry record must never embed argv payloads
+// (acli --body, orca --command carrying the agent prompt + RELAY_FLOW_*
+// env, JQL). sanitizeRetryMessage strips each "[args...]: " span while
+// preserving the surrounding wrap context and trailing stderr fragment.
+func TestSanitizeRetryMessage(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		// mustNot: argv payloads that must be stripped
+		mustNot []string
+		// mustContain: failure context that must survive
+		mustContain []string
+	}{
+		{
+			name: "acli comment with body payload",
+			in:   `acli [jira workitem comment create --key PAY-1 --body SECRET-BODY --json]: exit status 1: permission denied`,
+			mustNot: []string{"SECRET-BODY", "--body", "--key PAY-1"},
+			mustContain: []string{"acli", "exit status 1", "permission denied"},
+		},
+		{
+			name: "orca create with command payload",
+			in:   `ensure run X: orca terminal create: orca [terminal create --worktree name:PAY-1 --title PAY-1:coding --command 'RELAY_FLOW_RUN_ID=r1 opencode --agent coder PROMPT-TEXT']: exit status 1: closed`,
+			mustNot: []string{"PROMPT-TEXT", "RELAY_FLOW_RUN_ID=r1", "--command", "--title PAY-1:coding"},
+			mustContain: []string{"ensure run X", "orca terminal create", "exit status 1", "closed"},
+		},
+		{
+			name: "no brackets passes through",
+			in:   "plain failure",
+			mustContain: []string{"plain failure"},
+		},
+		{
+			name: "unterminated bracket passes through",
+			in:   "weird [unterminated",
+			mustContain: []string{"weird"},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := sanitizeRetryMessage(c.in)
+			for _, s := range c.mustNot {
+				if strings.Contains(got, s) {
+					t.Fatalf("sanitizeRetryMessage leaked %q in %q", s, got)
+				}
+			}
+			for _, s := range c.mustContain {
+				if !strings.Contains(got, s) {
+					t.Fatalf("sanitizeRetryMessage dropped %q from %q", s, got)
+				}
+			}
+		})
+	}
+}

package/internal/execution/goworkflows/retry_projection_test.go

@@ -0,0 +1,98 @@
+package goworkflows_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/execution/goworkflows"
+	"github.com/rajpopat27/relay-flow/internal/run"
+)
+
+func TestRunProjectionShowsActiveRetryAndClearsAfterRecovery(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	sys.completeFail = 1
+	engine := newEngine(t, goworkflows.Dependencies{
+		Repos: repoRegistryWith("payments", sys), Runner: newFakeRunner(log), Harness: newFakeHarness(log),
+	})
+	rid, err := startRun(engine, linearWorkflow(false))
+	if err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), rid)
+		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
+	})
+	r, _ := engine.GetRun(context.Background(), rid)
+	if _, err := engine.SubmitReport(context.Background(), reportRequest(rid, "coding", successReport("end"))); err != nil {
+		t.Fatal(err)
+	}
+
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ = engine.GetRun(context.Background(), rid)
+		return r.Retry != nil
+	})
+	if r.State != run.StateWaiting {
+		t.Fatalf("lifecycle state changed to %q during transient retry; want waiting", r.State)
+	}
+	if r.Retry.Attempt != 1 {
+		t.Fatalf("retry attempt = %d, want 1", r.Retry.Attempt)
+	}
+	if !strings.Contains(r.Retry.LastError, "jira unavailable") {
+		t.Fatalf("retry error = %q, want sanitized provider reason", r.Retry.LastError)
+	}
+	if !r.Retry.NextRetryAt.After(r.UpdatedAt) {
+		t.Fatalf("next retry %s is not after projection update %s", r.Retry.NextRetryAt, r.UpdatedAt)
+	}
+
+	listed, err := engine.ListRuns(context.Background(), run.Filter{Repo: "payments"})
+	if err != nil || len(listed) != 1 || listed[0].Retry == nil {
+		t.Fatalf("ListRuns retry projection = %+v, err=%v", listed, err)
+	}
+	byTicket, err := engine.FindRunByTicket(context.Background(), "PAY-101")
+	if err != nil || byTicket.Retry == nil {
+		t.Fatalf("FindRunByTicket retry projection = %+v, err=%v", byTicket, err)
+	}
+
+	waitFor(t, 15*time.Second, func() bool {
+		r, _ = engine.GetRun(context.Background(), rid)
+		return r.State == run.StateCompleted
+	})
+	if r.Retry != nil {
+		t.Fatalf("retry details remained after recovery: %+v", r.Retry)
+	}
+}
+
+func TestRunProjectionClearsRetryAfterCancellation(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	sys.completeFail = 100
+	engine := newEngine(t, goworkflows.Dependencies{
+		Repos: repoRegistryWith("payments", sys), Runner: newFakeRunner(log), Harness: newFakeHarness(log),
+	})
+	rid, _ := startRun(engine, linearWorkflow(false))
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), rid)
+		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
+	})
+	r, _ := engine.GetRun(context.Background(), rid)
+	if _, err := engine.SubmitReport(context.Background(), reportRequest(rid, "coding", successReport("end"))); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ = engine.GetRun(context.Background(), rid)
+		return r.Retry != nil
+	})
+	if err := engine.CancelRun(context.Background(), rid, "operator canceled"); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ = engine.GetRun(context.Background(), rid)
+		return r.State == run.StateCanceled
+	})
+	if r.Retry != nil {
+		t.Fatalf("retry details remained after terminal cancellation: %+v", r.Retry)
+	}
+}

package/internal/harness/contract_test.go

@@ -0,0 +1,169 @@
+package harness_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+// 3.8: harness contract tests against a fake harness, per
+// specs/integration-contracts "Harness owns agent launch semantics" and
+// specs/structured-node-reporting "Runtime plugin metadata is explicit".
+
+var errUnknownAgent = errors.New("unknown agent")
+
+type fakeHarness struct {
+	agents  map[string]bool
+	session map[string]harness.Session // title -> session
+}
+
+func newFakeHarness() *fakeHarness {
+	return &fakeHarness{
+		agents:  map[string]bool{"build": true},
+		session: map[string]harness.Session{},
+	}
+}
+
+func (f *fakeHarness) ValidateAgent(_ context.Context, _, agent string) error {
+	if !f.agents[agent] {
+		return errUnknownAgent
+	}
+	return nil
+}
+
+func (f *fakeHarness) FindSession(_ context.Context, _, title string) (harness.Session, bool, error) {
+	s, ok := f.session[title]
+	return s, ok, nil
+}
+
+func (f *fakeHarness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
+	// The fake mirrors the required env contract; the real opencode harness
+	// builds the executable/args. NEXT_STEPS_JSON carries the legal targets
+	// and their when explanations.
+	nextSteps, err := json.Marshal(spec.NextSteps)
+	if err != nil {
+		return runner.Command{}, err
+	}
+	return runner.Command{
+		Executable: "opencode",
+		Args:       []string{"--agent", spec.Agent},
+		Env: map[string]string{
+			"RELAY_FLOW_RUN_ID":          string(spec.RunID),
+			"RELAY_FLOW_WORKFLOW":        spec.Workflow,
+			"RELAY_FLOW_REPO":            spec.RepoName,
+			"RELAY_FLOW_TICKET":          spec.Ticket,
+			"RELAY_FLOW_NODE":            spec.Node,
+			"RELAY_FLOW_NODE_TYPE":       string(spec.NodeType),
+			"RELAY_FLOW_NUDGE_PROMPT":    spec.NudgePrompt,
+			"RELAY_FLOW_NEXT_STEPS_JSON": string(nextSteps),
+		},
+	}, nil
+}
+
+func launchSpec() harness.LaunchSpec {
+	return harness.LaunchSpec{
+		RunID:       identity.NewRunID("payments", "basicFlow", "PAY-101"),
+		NodeVisitID: identity.NewNodeVisitID(),
+		RepoName:    "payments",
+		RepoPath:    "/srv/payments",
+		Workflow:    "basicFlow",
+		Ticket:      "PAY-101",
+		Node:        "coding",
+		NodeType:    workflow.NodeAgent,
+		Agent:       "build",
+		Title:       "PAY-101:coding",
+		NextSteps: []workflow.Route{
+			{Target: "end", When: "work complete"},
+			{Target: "coding", When: "needs rework"},
+		},
+	}
+}
+
+func TestValidateAgent(t *testing.T) {
+	f := newFakeHarness()
+	if err := f.ValidateAgent(context.Background(), "/srv/payments", "build"); err != nil {
+		t.Fatalf("known agent rejected: %v", err)
+	}
+	if err := f.ValidateAgent(context.Background(), "/srv/payments", "unknown"); err == nil {
+		t.Fatal("unknown agent accepted")
+	}
+}
+
+func TestFindSessionByStableTitle(t *testing.T) {
+	f := newFakeHarness()
+	f.session["PAY-101:coding"] = harness.Session{ID: "s1", Title: "PAY-101:coding"}
+
+	s, ok, err := f.FindSession(context.Background(), "/srv/payments", "PAY-101:coding")
+	if err != nil || !ok || s.ID != "s1" {
+		t.Fatalf("FindSession = %v,%v,%v", s, ok, err)
+	}
+	_, ok, err = f.FindSession(context.Background(), "/srv/payments", "PAY-101:review")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ok {
+		t.Fatal("FindSession found a session for an unknown title")
+	}
+}
+
+func TestBuildCommandEnvContract(t *testing.T) {
+	f := newFakeHarness()
+	spec := launchSpec()
+	cmd, err := f.BuildCommand(spec)
+	if err != nil {
+		t.Fatalf("BuildCommand failed: %v", err)
+	}
+
+	required := []string{
+		"RELAY_FLOW_RUN_ID",
+		"RELAY_FLOW_WORKFLOW",
+		"RELAY_FLOW_REPO",
+		"RELAY_FLOW_TICKET",
+		"RELAY_FLOW_NODE",
+		"RELAY_FLOW_NODE_TYPE",
+		"RELAY_FLOW_NUDGE_PROMPT",
+		"RELAY_FLOW_NEXT_STEPS_JSON",
+	}
+	for _, key := range required {
+		if _, ok := cmd.Env[key]; !ok {
+			t.Fatalf("command env missing %s (env=%v)", key, cmd.Env)
+		}
+	}
+	if cmd.Env["RELAY_FLOW_RUN_ID"] != string(spec.RunID) {
+		t.Fatalf("RELAY_FLOW_RUN_ID = %q", cmd.Env["RELAY_FLOW_RUN_ID"])
+	}
+	if cmd.Env["RELAY_FLOW_TICKET"] != "PAY-101" || cmd.Env["RELAY_FLOW_NODE"] != "coding" {
+		t.Fatalf("ticket/node env wrong: %v", cmd.Env)
+	}
+
+	// NEXT_STEPS_JSON must decode to the legal targets and their when
+	// explanations, not just exist.
+	var steps []map[string]string
+	if err := json.Unmarshal([]byte(cmd.Env["RELAY_FLOW_NEXT_STEPS_JSON"]), &steps); err != nil {
+		t.Fatalf("NEXT_STEPS_JSON not valid JSON: %v", err)
+	}
+	if len(steps) != 2 {
+		t.Fatalf("NEXT_STEPS_JSON = %v, want 2 legal targets", steps)
+	}
+	found := map[string]string{}
+	for _, s := range steps {
+		found[s["target"]] = s["when"]
+	}
+	if found["end"] != "work complete" || found["coding"] != "needs rework" {
+		t.Fatalf("NEXT_STEPS_JSON targets/when = %v", found)
+	}
+}
+
+func TestHarnessDoesNotManipulateRunnerState(t *testing.T) {
+	// The harness returns a structured runner.Command; it never receives or
+	// mutates runner terminals/environments. Compile-time shape check:
+	// Harness methods take repoPath/title/spec values, not runner state.
+	var h harness.Harness = newFakeHarness()
+	_ = h
+}

package/internal/harness/factory.go

@@ -0,0 +1,63 @@
+package harness
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// Factory constructs a Harness from root harness config.
+type Factory func(config.RawValues) (Harness, error)
+
+var (
+	registryMu sync.RWMutex
+	registry   = map[string]Factory{}
+)
+
+// Register adds a harness factory by name. Duplicate registration panics.
+func Register(name string, factory Factory) {
+	registryMu.Lock()
+	defer registryMu.Unlock()
+	if _, exists := registry[name]; exists {
+		panic(fmt.Sprintf("harness: duplicate registration of %q", name))
+	}
+	registry[name] = factory
+}
+
+// New constructs the named harness.
+func New(name string, cfg config.RawValues) (Harness, error) {
+	registryMu.RLock()
+	f, ok := registry[name]
+	registryMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("harness: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return f(cfg)
+}
+
+// ValidateName returns an error listing registered names when name is not
+// a registered plugin. Used by `relay-flow init` to reject unknown plugin
+// selections without constructing a Harness.
+func ValidateName(name string) error {
+	registryMu.RLock()
+	defer registryMu.RUnlock()
+	if _, ok := registry[name]; !ok {
+		return fmt.Errorf("harness: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return nil
+}
+
+// Names returns the registered plugin names sorted.
+func Names() []string {
+	registryMu.RLock()
+	defer registryMu.RUnlock()
+	out := make([]string, 0, len(registry))
+	for name := range registry {
+		out = append(out, name)
+	}
+	sort.Strings(out)
+	return out
+}

package/internal/harness/harness.go

@@ -0,0 +1,41 @@
+// Package harness defines the harness contract: agent validation, session
+// discovery, resume syntax, and launch command construction. The runner
+// executes the returned command; the harness never manipulates runner
+// state.
+package harness
+
+import (
+	"context"
+
+	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+type Session struct {
+	ID    string
+	Title string
+}
+
+type LaunchSpec struct {
+	RunID       identity.RunID
+	NodeVisitID identity.NodeVisitID
+	RepoName    string
+	RepoPath    string
+	Workflow    string
+	Ticket      string
+	Node        string
+	NodeType    workflow.NodeType
+	Agent       string
+	Title       string
+	Prompt      string
+	NudgePrompt string
+	NextSteps   []workflow.Route
+	ResumeID    string
+}
+
+type Harness interface {
+	ValidateAgent(ctx context.Context, repoPath, agent string) error
+	FindSession(ctx context.Context, repoPath, title string) (Session, bool, error)
+	BuildCommand(spec LaunchSpec) (runner.Command, error)
+}

package/internal/harness/opencode/opencode.go

@@ -0,0 +1,166 @@
+// Package opencode is the built-in launch-time Harness adapter for the
+// OpenCode agent runtime. It validates agents, finds prior sessions by
+// their stable <ticket>:<node> title, and builds the structured command
+// the runner executes. The OpenCode runtime plugin (TypeScript, under
+// plugin/) owns message parsing, title pinning, nudge-on-invalid for
+// agent nodes, silence for HITL, and exact-report JSON retry with the
+// shared backoff constants mirrored in TypeScript.
+package opencode
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+)
+
+// Config is the adapter-owned root harnessConfig. OpenCode takes no
+// configuration; any key is rejected.
+type Config struct{}
+
+func init() {
+	harness.Register("opencode", func(raw config.RawValues) (harness.Harness, error) {
+		var cfg Config
+		if err := config.DecodeStrict(raw, &cfg); err != nil {
+			return nil, fmt.Errorf("opencode harnessConfig: %w", err)
+		}
+		return New(), nil
+	})
+}
+
+// Harness implements harness.Harness for OpenCode. It is safe for
+// concurrent use; the seams below are only swapped by tests before use.
+type Harness struct {
+	// listAgents is the test seam; nil → real `opencode agent list`.
+	listAgents func(ctx context.Context) ([]string, error)
+}
+
+// New returns the production Harness.
+func New() *Harness { return &Harness{} }
+
+// ValidateAgent reports whether name is a known OpenCode agent for the
+// repo, per `opencode agent list` (agent names are the unindented first
+// tokens).
+func (h *Harness) ValidateAgent(ctx context.Context, _ string, agent string) error {
+	if agent == "" {
+		return fmt.Errorf("opencode: agent name is empty")
+	}
+	list := h.listAgents
+	if list == nil {
+		list = listAgents
+	}
+	names, err := list(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range names {
+		if n == agent {
+			return nil
+		}
+	}
+	return fmt.Errorf("opencode: unknown agent %q", agent)
+}
+
+// FindSession is intentionally discovery-free. Normal execution resumes only
+// the session ID persisted from an OpenCode event.
+func (h *Harness) FindSession(context.Context, string, string) (harness.Session, bool, error) {
+	return harness.Session{}, false, nil
+}
+
+// BuildCommand returns the structured opencode invocation with the
+// required RELAY_FLOW_* env. spec.ResumeID non-empty resumes the prior
+// session (`opencode --session <id>`); empty is a fresh launch. The
+// prompt is delivered as the first message in both cases.
+//
+// 9.5 external-call logging: this is the harness launch boundary — the
+// runner executes the returned command. One debug line carries agent +
+// session id + resume/fresh; one info line carries only the outcome.
+func (h *Harness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
+	mode := "fresh"
+	if spec.ResumeID != "" {
+		mode = "resume"
+	}
+	slog.Debug("harness call",
+		"op", "launch", "agent", spec.Agent, "session", spec.ResumeID, "mode", mode,
+		"ticket", spec.Ticket, "runID", string(spec.RunID),
+		"node", spec.Node, "nodeVisitID", string(spec.NodeVisitID))
+	if spec.Agent == "" {
+		err := fmt.Errorf("opencode: LaunchSpec.Agent is empty")
+		slog.Info("harness outcome", "op", "launch", "agent", spec.Agent, "mode", mode, "result", "error", "error", err)
+		return runner.Command{}, err
+	}
+	nextSteps, err := json.Marshal(spec.NextSteps)
+	if err != nil {
+		slog.Info("harness outcome", "op", "launch", "agent", spec.Agent, "mode", mode, "result", "error", "error", err)
+		return runner.Command{}, fmt.Errorf("opencode: marshal next steps: %w", err)
+	}
+	root, err := relayFlowHome()
+	if err != nil {
+		return runner.Command{}, err
+	}
+	env := map[string]string{
+		"RELAY_FLOW_HOME":            root,
+		"RELAY_FLOW_RUN_ID":          string(spec.RunID),
+		"RELAY_FLOW_WORKFLOW":        spec.Workflow,
+		"RELAY_FLOW_REPO":            spec.RepoName,
+		"RELAY_FLOW_TICKET":          spec.Ticket,
+		"RELAY_FLOW_NODE":            spec.Node,
+		"RELAY_FLOW_NODE_TYPE":       string(spec.NodeType),
+		"RELAY_FLOW_NUDGE_PROMPT":    spec.NudgePrompt,
+		"RELAY_FLOW_NEXT_STEPS_JSON": string(nextSteps),
+	}
+	args := []string{}
+	if spec.ResumeID != "" {
+		args = append(args, "--session", spec.ResumeID)
+	}
+	args = append(args, "--agent", spec.Agent, "--prompt", spec.Prompt)
+	slog.Info("harness outcome",
+		"op", "launch", "agent", spec.Agent, "session", spec.ResumeID, "mode", mode,
+		"ticket", spec.Ticket, "runID", string(spec.RunID),
+		"node", spec.Node, "nodeVisitID", string(spec.NodeVisitID),
+		"result", "ok")
+	return runner.Command{
+		Executable: "opencode",
+		Args:       args,
+		Env:        env,
+	}, nil
+}
+
+func relayFlowHome() (string, error) {
+	if root := os.Getenv("RELAY_FLOW_HOME"); root != "" {
+		return root, nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("opencode: resolve relay-flow home: %w", err)
+	}
+	return filepath.Join(home, ".relay-flow"), nil
+}
+
+// listAgents runs `opencode agent list` and returns the agent names
+// (the unindented lines' first tokens).
+func listAgents(ctx context.Context) ([]string, error) {
+	out, err := exec.CommandContext(ctx, "opencode", "agent", "list").Output()
+	if err != nil {
+		return nil, fmt.Errorf("opencode agent list: %w", err)
+	}
+	var names []string
+	for _, line := range strings.Split(string(out), "\n") {
+		if line == "" || line[0] == ' ' || line[0] == '[' || line[0] == '{' {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) > 0 {
+			names = append(names, fields[0])
+		}
+	}
+	return names, nil
+}

package/internal/harness/opencode/opencode_test.go

@@ -0,0 +1,50 @@
+package opencode_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/harness/opencode"
+)
+
+func TestBuildCommandArgv(t *testing.T) {
+	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
+	tests := []struct {
+		name     string
+		resumeID string
+		want     []string
+	}{
+		{
+			name: "fresh",
+			want: []string{"--agent", "build", "--prompt", "implement the ticket"},
+		},
+		{
+			name:     "resumed",
+			resumeID: "session-123",
+			want:     []string{"--session", "session-123", "--agent", "build", "--prompt", "implement the ticket"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd, err := opencode.New().BuildCommand(harness.LaunchSpec{
+				Agent:    "build",
+				Prompt:   "implement the ticket",
+				ResumeID: tt.resumeID,
+			})
+			if err != nil {
+				t.Fatalf("BuildCommand: %v", err)
+			}
+			if cmd.Executable != "opencode" {
+				t.Fatalf("Executable = %q, want opencode", cmd.Executable)
+			}
+			if !reflect.DeepEqual(cmd.Args, tt.want) {
+				t.Fatalf("Args = %#v, want %#v", cmd.Args, tt.want)
+			}
+			if cmd.Env["RELAY_FLOW_HOME"] != "/var/lib/relay-flow-test" {
+				t.Fatalf("RELAY_FLOW_HOME = %q", cmd.Env["RELAY_FLOW_HOME"])
+			}
+		})
+	}
+}