relay-flow 0.1.0-alpha.0

package/internal/runner/orca/orca_test.go

@@ -0,0 +1,201 @@
+package orca
+
+import (
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/orcacli"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+type fakeOrca struct {
+	listErr      error
+	worktrees    []orcacli.Worktree
+	terminals    map[string][]orcacli.Terminal // worktree name → terminals
+	created      []string
+	sent         []string
+	closed       []string
+	waitErr      error
+	createErr    error
+	findBranchFn func(repoPath, key string) (string, bool, error)
+	agentExists  bool
+}
+
+func (f *fakeOrca) WorktreeList() ([]orcacli.Worktree, error) { return f.worktrees, nil }
+func (f *fakeOrca) WorktreeCreate(ticketKey, repoID, parentWorktreeID, baseBranch string) error {
+	f.created = append(f.created, ticketKey)
+	f.worktrees = append(f.worktrees, orcacli.Worktree{ID: "wt-" + ticketKey, DisplayName: ticketKey, RepoID: repoID, Branch: baseBranch})
+	return nil
+}
+func (f *fakeOrca) FindWorktree(repoID, displayName string) (orcacli.Worktree, bool, error) {
+	for _, w := range f.worktrees {
+		if w.RepoID == repoID && w.DisplayName == displayName {
+			return w, true, nil
+		}
+	}
+	return orcacli.Worktree{}, false, nil
+}
+func (f *fakeOrca) MainWorktree(repoID string) (orcacli.Worktree, bool, error) {
+	for _, w := range f.worktrees {
+		if w.RepoID == repoID && w.IsMainWorktree {
+			return w, true, nil
+		}
+	}
+	return orcacli.Worktree{}, false, nil
+}
+func (f *fakeOrca) TerminalList(worktree string) ([]orcacli.Terminal, error) {
+	if f.listErr != nil {
+		return nil, f.listErr
+	}
+	return f.terminals[worktree], nil
+}
+func (f *fakeOrca) TerminalCreate(ticketKey, title, command string) (string, error) {
+	if f.createErr != nil {
+		return "", f.createErr
+	}
+	h := "h-" + title
+	f.terminals["name:"+ticketKey] = append(f.terminals["name:"+ticketKey], orcacli.Terminal{Handle: h, Title: title, Connected: true})
+	return h, nil
+}
+func (f *fakeOrca) TerminalWait(handle, forState string, timeoutMs int) error { return f.waitErr }
+func (f *fakeOrca) TerminalClose(handle string) error {
+	f.closed = append(f.closed, handle)
+	return nil
+}
+func (f *fakeOrca) TerminalSend(handle, text string) error {
+	f.sent = append(f.sent, handle+":"+text)
+	return nil
+}
+
+func newTestRunner(f *fakeOrca) *orcaRunner {
+	return &orcaRunner{
+		repoID: "repo-1",
+		orca:   f,
+		exists: func(string) (bool, error) { return f.agentExists, nil },
+		sleep:  func(time.Duration) {},
+		findBranch: func(repoPath, key string) (string, bool, error) {
+			if f.findBranchFn != nil {
+				return f.findBranchFn(repoPath, key)
+			}
+			return "", false, nil
+		},
+	}
+}
+
+func TestUnmarshalConfig(t *testing.T) {
+	if _, err := unmarshalConfig(map[string]any{}); err != nil {
+		t.Fatalf("empty config must be valid: %v", err)
+	}
+	if _, err := unmarshalConfig(nil); err != nil {
+		t.Fatalf("nil config must be valid: %v", err)
+	}
+	if _, err := unmarshalConfig(map[string]any{"bogus": 1}); err == nil {
+		t.Fatal("unknown field must be rejected")
+	}
+}
+
+func TestSpawnCreatesWorktreeAndTerminal(t *testing.T) {
+	f := &fakeOrca{
+		worktrees:   []orcacli.Worktree{{ID: "main", DisplayName: "main", RepoID: "repo-1", IsMainWorktree: true, Branch: "main", Path: "/tmp"}},
+		terminals:   map[string][]orcacli.Terminal{},
+		agentExists: true,
+	}
+	r := newTestRunner(f)
+	tk := tasks.Ticket{Key: "XYZ-1"}
+	err := r.Spawn(tk, "coding", "build", "do the work", map[string]string{
+		"RELAY_FLOW_WORKFLOW": "wf", "RELAY_FLOW_TICKET": "XYZ-1", "RELAY_FLOW_NODE": "coding", "RELAY_FLOW_AGENT": "build",
+	})
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(f.created) != 1 || f.created[0] != "XYZ-1" {
+		t.Errorf("worktree created = %v", f.created)
+	}
+	terms := f.terminals["name:XYZ-1"]
+	if len(terms) != 1 || terms[0].Title != "XYZ-1:build:coding" {
+		t.Errorf("terminals = %+v", terms)
+	}
+}
+
+func TestSpawnUnknownAgent(t *testing.T) {
+	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{}, agentExists: false}
+	r := newTestRunner(f)
+	if err := r.Spawn(tasks.Ticket{Key: "XYZ-1"}, "coding", "ghost", "p", nil); err == nil {
+		t.Fatal("unknown agent must error")
+	}
+	if len(f.created) != 0 {
+		t.Errorf("no worktree should be created for unknown agent: %v", f.created)
+	}
+}
+
+func TestFindExactTitle(t *testing.T) {
+	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{
+		"name:XYZ-1": {
+			{Handle: "h1", Title: "XYZ-1:build:coding"},
+			{Handle: "h2", Title: "XYZ-1:build:reviewing"},
+			{Handle: "h3", Title: "Terminal 1"},
+		},
+	}}
+	r := newTestRunner(f)
+	s, ok, err := r.Find(tasks.Ticket{Key: "XYZ-1"}, "coding")
+	if err != nil || !ok || s.ID != "h1" {
+		t.Errorf("Find coding = %+v ok=%v err=%v", s, ok, err)
+	}
+	if _, ok, _ := r.Find(tasks.Ticket{Key: "XYZ-1"}, "nowhere"); ok {
+		t.Error("Find nowhere must miss")
+	}
+	if _, ok, _ := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); ok {
+		t.Error("Find unknown ticket must miss")
+	}
+}
+
+func TestFindMissingWorktreeIsNotFound(t *testing.T) {
+	// selector_not_found (worktree gone after crash) must be "no session",
+	// not an error — otherwise bounce never reaches the respawn branch.
+	f := &fakeOrca{listErr: errSelectorNotFound}
+	r := newTestRunner(f)
+	if _, ok, err := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); err != nil || ok {
+		t.Errorf("Find = ok=%v err=%v, want no-session", ok, err)
+	}
+	// Real errors still propagate.
+	f.listErr = errBoom
+	if _, _, err := r.Find(tasks.Ticket{Key: "XYZ-9"}, "coding"); err == nil {
+		t.Error("real list error must propagate")
+	}
+}
+
+var errSelectorNotFound = errorString("exit status 1: selector_not_found")
+var errBoom = errorString("boom")
+
+type errorString string
+
+func (e errorString) Error() string { return string(e) }
+
+func TestNudgeSendsPrompt(t *testing.T) {
+	f := &fakeOrca{}
+	r := newTestRunner(f)
+	if err := r.Nudge(runner.Session{ID: "h1", Title: "XYZ-1:build:coding"}, "continue please"); err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(f.sent) != 1 || f.sent[0] != "h1:continue please" {
+		t.Errorf("sent = %v", f.sent)
+	}
+}
+
+func TestCloseClosesTicketTerminals(t *testing.T) {
+	f := &fakeOrca{terminals: map[string][]orcacli.Terminal{
+		"name:XYZ-1": {
+			{Handle: "h1", Title: "XYZ-1:build:coding"},
+			{Handle: "h2", Title: "XYZ-1:build:reviewing"},
+			{Handle: "h3", Title: "Setup"}, // not ours — survives
+		},
+	}}
+	r := newTestRunner(f)
+	if err := r.Close(tasks.Ticket{Key: "XYZ-1"}); err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(f.closed) != 2 {
+		t.Errorf("closed = %v, want h1+h2 only", f.closed)
+	}
+}

package/internal/runner/runner.go

@@ -0,0 +1,81 @@
+// Package runner defines the execution-backend plug point. Orca ships
+// built in (internal/runner/orca); tmux or others register the same way.
+// A Runner knows how to spawn agent sessions, re-find them (bounce),
+// nudge them, and tear them down — nothing about trackers.
+package runner
+
+import (
+	"fmt"
+	"sort"
+	"sync"
+
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+// Session is a live agent terminal/process handle.
+type Session struct {
+	ID    string
+	Title string
+}
+
+// Runner is the execution-backend interface.
+type Runner interface {
+	// Spawn creates (or ensures) the ticket's worktree/session titled
+	// "<key>:<agent>:<node>", injects env, and sends the initial prompt.
+	Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error
+	// Find locates the existing session for this ticket+node (bounce).
+	Find(t tasks.Ticket, node string) (Session, bool, error)
+	// Nudge sends a prompt into an existing session.
+	Nudge(s Session, prompt string) error
+	// Close tears down all of the ticket's sessions (terminal node).
+	Close(t tasks.Ticket) error
+}
+
+// Factory builds a runner instance. runner.config is decoded by
+// UnmarshalConfig (strict), then passed to New.
+type Factory struct {
+	UnmarshalConfig func(map[string]any) (any, error)
+	New             func(cfg any) (Runner, error)
+}
+
+var (
+	mu        sync.RWMutex
+	factories = map[string]Factory{}
+)
+
+// Register makes a runner available under `type: <name>`. Panics on
+// duplicate registration (programmer error).
+func Register(name string, f Factory) {
+	mu.Lock()
+	defer mu.Unlock()
+	if _, dup := factories[name]; dup {
+		panic("runner: duplicate registration " + name)
+	}
+	factories[name] = f
+}
+
+// New resolves a runner by type name and builds an instance.
+func New(typeName string, rawCfg map[string]any) (Runner, error) {
+	mu.RLock()
+	f, ok := factories[typeName]
+	mu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("unknown runner type %q (registered: %v)", typeName, registered())
+	}
+	cfg, err := f.UnmarshalConfig(rawCfg)
+	if err != nil {
+		return nil, fmt.Errorf("runner type %q config: %w", typeName, err)
+	}
+	return f.New(cfg)
+}
+
+func registered() []string {
+	mu.RLock()
+	defer mu.RUnlock()
+	names := make([]string, 0, len(factories))
+	for n := range factories {
+		names = append(names, n)
+	}
+	sort.Strings(names)
+	return names
+}

package/internal/runner/runner_test.go

@@ -0,0 +1,64 @@
+package runner
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/tasks"
+)
+
+type fakeRunner struct {
+	spawned []string
+	nudged  []string
+	closed  []string
+	found   map[string]Session
+}
+
+func (f *fakeRunner) Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error {
+	f.spawned = append(f.spawned, t.Key+":"+node+":"+agent+":"+env["RELAY_WORKFLOW"])
+	return nil
+}
+func (f *fakeRunner) Find(t tasks.Ticket, node string) (Session, bool, error) {
+	s, ok := f.found[t.Key+":"+node]
+	return s, ok, nil
+}
+func (f *fakeRunner) Nudge(s Session, prompt string) error {
+	f.nudged = append(f.nudged, s.Title+":"+prompt)
+	return nil
+}
+func (f *fakeRunner) Close(t tasks.Ticket) error {
+	f.closed = append(f.closed, t.Key)
+	return nil
+}
+
+func TestRegistryNew(t *testing.T) {
+	fake := &fakeRunner{}
+	Register("fakerun", Factory{
+		UnmarshalConfig: func(m map[string]any) (any, error) { return m, nil },
+		New: func(cfg any) (Runner, error) { return fake, nil },
+	})
+
+	r, err := New("fakerun", nil)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	tk := tasks.Ticket{Key: "XYZ-2"}
+	r.Spawn(tk, "coding", "build", "go", map[string]string{"RELAY_WORKFLOW": "w"})
+	if len(fake.spawned) != 1 || fake.spawned[0] != "XYZ-2:coding:build:w" {
+		t.Errorf("spawned = %v", fake.spawned)
+	}
+
+	if _, err := New("nope", nil); err == nil || !strings.Contains(err.Error(), "unknown runner type") {
+		t.Errorf("unknown runner error = %v", err)
+	}
+}
+
+func TestDuplicateRegisterPanics(t *testing.T) {
+	defer func() {
+		if recover() == nil {
+			t.Fatal("expected panic on duplicate registration")
+		}
+	}()
+	Register("duprun", Factory{})
+	Register("duprun", Factory{})
+}

package/internal/server/client.go

@@ -0,0 +1,126 @@
+package server
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+
+	"github.com/rajpopat27/relay-flow/internal/discovery"
+)
+
+// Client talks to a running `serve` process over its unix socket. Zero
+// value is unusable; construct with NewClient (prod socket) or set Socket
+// directly (tests).
+type Client struct {
+	Socket string
+}
+
+// NewClient returns a Client for the default socket path.
+func NewClient() (*Client, error) {
+	p, err := discovery.SocketPath()
+	if err != nil {
+		return nil, err
+	}
+	return &Client{Socket: p}, nil
+}
+
+func (c *Client) httpClient() *http.Client {
+	return &http.Client{Transport: &http.Transport{
+		DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
+			return net.Dial("unix", c.Socket)
+		},
+	}}
+}
+
+func (c *Client) do(method, path string, body any) error {
+	var rdr *bytes.Reader
+	if body != nil {
+		b, _ := json.Marshal(body)
+		rdr = bytes.NewReader(b)
+	} else {
+		rdr = bytes.NewReader(nil)
+	}
+	req, err := http.NewRequest(method, "http://unix"+path, rdr)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.httpClient().Do(req)
+	if err != nil {
+		if _, statErr := os.Stat(c.Socket); os.IsNotExist(statErr) {
+			return fmt.Errorf("no server at %s — is `relay-flow serve` running?", c.Socket)
+		}
+		return fmt.Errorf("server call %s %s: %w (is `relay-flow serve` running?)", method, path, err)
+	}
+	defer resp.Body.Close()
+	var env struct {
+		OK  bool   `json:"ok"`
+		Err string `json:"error"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
+		return fmt.Errorf("decode server reply: %w", err)
+	}
+	if resp.StatusCode >= 400 || (!env.OK && env.Err != "") {
+		if env.Err != "" {
+			return fmt.Errorf("server: %s", env.Err)
+		}
+		return fmt.Errorf("server: status %d", resp.StatusCode)
+	}
+	return nil
+}
+
+// Submit sends a workflow YAML to the server (wired end-to-end in P6).
+func (c *Client) Submit(repoPath string, yamlBytes []byte) error {
+	return c.do("POST", "/submit", map[string]string{
+		"repoPath": repoPath, "yaml": string(yamlBytes),
+	})
+}
+
+// Shutdown asks the server to stop.
+func (c *Client) Shutdown() error {
+	return c.do("POST", "/shutdown", nil)
+}
+
+// ReportResult is the server's reply to a report call.
+type ReportResult struct {
+	Action string `json:"action"` // transitioned | commented | error
+	Detail string `json:"detail"`
+}
+
+// Report posts an agent outcome to the server, which routes it to the
+// workflow's tasks adapter.
+func (c *Client) Report(workflow, ticket, node, outcome, summary string) (*ReportResult, error) {
+	b, _ := json.Marshal(map[string]string{
+		"workflow": workflow, "ticket": ticket, "node": node, "outcome": outcome, "summary": summary,
+	})
+	req, err := http.NewRequest("POST", "http://unix/report", bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.httpClient().Do(req)
+	if err != nil {
+		if _, statErr := os.Stat(c.Socket); os.IsNotExist(statErr) {
+			return nil, fmt.Errorf("no server at %s — is `relay-flow serve` running?", c.Socket)
+		}
+		return nil, fmt.Errorf("server call POST /report: %w", err)
+	}
+	defer resp.Body.Close()
+	var out struct {
+		OK     bool   `json:"ok"`
+		Err    string `json:"error"`
+		Action string `json:"action"`
+		Detail string `json:"detail"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		return nil, fmt.Errorf("decode server reply: %w", err)
+	}
+	if resp.StatusCode >= 400 || (!out.OK && out.Err != "") {
+		return nil, fmt.Errorf("server: %s", out.Err)
+	}
+	return &ReportResult{Action: out.Action, Detail: out.Detail}, nil
+}