relay-flow 0.0.1 → 0.2.0-alpha

package/internal/runner/orca/orcacli/orcacli_test.go

@@ -0,0 +1,154 @@
+package orcacli
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCLIContractsAgainstCapturedRealOutput(t *testing.T) {
+	installStrictFakeOrca(t)
+	ctx := context.Background()
+	cli := New()
+
+	repos, err := cli.ListRepos(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(repos) != 1 || repos[0].ID != "repo-1" || repos[0].DisplayName != "app" || repos[0].Path != "/srv/app" {
+		t.Fatalf("ListRepos = %+v", repos)
+	}
+
+	worktrees, err := cli.ListWorktrees(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(worktrees) != 1 || worktrees[0].ID != "wt-main" || worktrees[0].Branch != "refs/heads/master" || !worktrees[0].IsMainWorktree {
+		t.Fatalf("ListWorktrees = %+v", worktrees)
+	}
+
+	if err := cli.CreateWorktree(ctx, "PAY-101", "repo-1", "wt-main", "origin/alice/PAY-101"); err != nil {
+		t.Fatal(err)
+	}
+	if err := cli.DeleteWorktree(ctx, "wt-PAY-101"); err != nil {
+		t.Fatal(err)
+	}
+
+	terminals, err := cli.ListTerminals(ctx, "id:wt-PAY-101")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(terminals) != 1 {
+		t.Fatalf("ListTerminals = %+v", terminals)
+	}
+	if got := terminals[0]; got.Handle != "term-1" || got.Title != "PAY-101:implement" || !got.Connected {
+		t.Fatalf("ListTerminals[0] = %+v", got)
+	}
+	if terminals[0].Title == "opencode" {
+		t.Fatal("ListTerminals used mutable pane title instead of stable visualLayouts tab title")
+	}
+	direct, err := cli.ShowTerminal(ctx, "term-1")
+	if err != nil || direct.Handle != "term-1" || !direct.Connected {
+		t.Fatalf("ShowTerminal = %+v, %v", direct, err)
+	}
+	if err := cli.SendTerminal(ctx, "term-1", "hello"); err != nil {
+		t.Fatal(err)
+	}
+
+	handle, err := cli.CreateTerminal(ctx, "PAY-101", "PAY-101:implement", "echo hello")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if handle != "term-1" {
+		t.Fatalf("CreateTerminal handle = %q", handle)
+	}
+	if err := cli.CloseTerminal(ctx, handle); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestStrictFakeOrcaRejectsMissingFlags(t *testing.T) {
+	fake := installStrictFakeOrca(t)
+	if err := exec.Command(fake, "terminal", "list", "--worktree", "id:wt-PAY-101", "--json").Run(); err == nil {
+		t.Fatal("strict fake accepted terminal list without --include-visual-layouts")
+	}
+}
+
+func TestFindExistingBranchLocalOnly(t *testing.T) {
+	repo := newGitRepo(t)
+	runGit(t, repo, "branch", "alice/PAY-101")
+
+	got, ok, err := FindExistingBranch(repo, "PAY-101")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok || got != "alice/PAY-101" {
+		t.Fatalf("FindExistingBranch = %q, %v; want alice/PAY-101, true", got, ok)
+	}
+}
+
+func TestFindExistingBranchRemoteOnly(t *testing.T) {
+	repo := newGitRepo(t)
+	runGit(t, repo, "update-ref", "refs/remotes/origin/alice/PAY-102", "HEAD")
+
+	got, ok, err := FindExistingBranch(repo, "PAY-102")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok || got != "origin/alice/PAY-102" {
+		t.Fatalf("FindExistingBranch = %q, %v; want origin/alice/PAY-102, true", got, ok)
+	}
+}
+
+func TestFindExistingBranchMissing(t *testing.T) {
+	repo := newGitRepo(t)
+	runGit(t, repo, "branch", "alice/OTHER-1")
+
+	got, ok, err := FindExistingBranch(repo, "PAY-103")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ok || got != "" {
+		t.Fatalf("FindExistingBranch = %q, %v; want empty, false", got, ok)
+	}
+}
+
+func newGitRepo(t *testing.T) string {
+	t.Helper()
+	repo := t.TempDir()
+	runGit(t, repo, "init", "--quiet")
+	runGit(t, repo, "-c", "user.name=Relay Flow", "-c", "user.email=relay-flow@example.invalid", "commit", "--allow-empty", "--quiet", "-m", "initial")
+	return repo
+}
+
+func runGit(t *testing.T, repo string, args ...string) {
+	t.Helper()
+	cmdArgs := append([]string{"-C", repo}, args...)
+	out, err := exec.Command("git", cmdArgs...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %s: %v: %s", strings.Join(args, " "), err, out)
+	}
+}
+
+func installStrictFakeOrca(t *testing.T) string {
+	t.Helper()
+	binDir := t.TempDir()
+	fake := filepath.Join(binDir, "orca")
+	script, err := os.ReadFile(filepath.Join("testdata", "strict-orca.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(fake, script, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	fixtureDir, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ORCA_FIXTURE_DIR", fixtureDir)
+	t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	return fake
+}

package/internal/runner/orca/orcacli/testdata/repo-list.json

@@ -0,0 +1,18 @@
+{
+  "id": "captured-repo-list",
+  "ok": true,
+  "result": {
+    "repos": [
+      {
+        "id": "repo-1",
+        "path": "/srv/app",
+        "displayName": "app",
+        "kind": "git",
+        "externalWorktreeVisibility": "hide",
+        "upstream": null,
+        "gitRemoteIdentity": null
+      }
+    ]
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/strict-orca.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+set -eu
+
+fixture=
+if [ "$#" -eq 3 ] && [ "$1" = repo ] && [ "$2" = list ] && [ "$3" = --json ]; then
+  fixture=repo-list.json
+elif [ "$#" -eq 3 ] && [ "$1" = worktree ] && [ "$2" = list ] && [ "$3" = --json ]; then
+  fixture=worktree-list.json
+elif [ "$#" -eq 11 ] && [ "$1" = worktree ] && [ "$2" = create ] && [ "$3" = --name ] && [ "$4" = PAY-101 ] && [ "$5" = --repo ] && [ "$6" = id:repo-1 ] && [ "$7" = --parent-worktree ] && [ "$8" = worktree:wt-main ] && [ "$9" = --base-branch ] && [ "${10}" = origin/alice/PAY-101 ] && [ "${11}" = --json ]; then
+  fixture=worktree-create.json
+elif [ "$#" -eq 5 ] && [ "$1" = worktree ] && [ "$2" = rm ] && [ "$3" = --worktree ] && [ "$4" = id:wt-PAY-101 ] && [ "$5" = --json ]; then
+  fixture=worktree-remove.json
+elif [ "$#" -eq 6 ] && [ "$1" = terminal ] && [ "$2" = list ] && [ "$3" = --worktree ] && [ "$4" = id:wt-PAY-101 ] && [ "$5" = --include-visual-layouts ] && [ "$6" = --json ]; then
+  fixture=terminal-list.json
+elif [ "$#" -eq 5 ] && [ "$1" = terminal ] && [ "$2" = show ] && [ "$3" = --terminal ] && [ "$4" = term-1 ] && [ "$5" = --json ]; then
+  fixture=terminal-show.json
+elif [ "$#" -eq 8 ] && [ "$1" = terminal ] && [ "$2" = send ] && [ "$3" = --terminal ] && [ "$4" = term-1 ] && [ "$5" = --text ] && [ "$6" = 'hello' ] && [ "$7" = --enter ] && [ "$8" = --json ]; then
+  fixture=terminal-send.json
+elif [ "$#" -eq 9 ] && [ "$1" = terminal ] && [ "$2" = create ] && [ "$3" = --worktree ] && [ "$4" = name:PAY-101 ] && [ "$5" = --title ] && [ "$6" = PAY-101:implement ] && [ "$7" = --command ] && [ "$8" = 'echo hello' ] && [ "$9" = --json ]; then
+  fixture=terminal-create.json
+elif [ "$#" -eq 5 ] && [ "$1" = terminal ] && [ "$2" = close ] && [ "$3" = --terminal ] && [ "$4" = term-1 ] && [ "$5" = --json ]; then
+  fixture=terminal-close.json
+else
+  printf 'unsupported or malformed orca invocation:' >&2
+  printf ' <%s>' "$@" >&2
+  printf '\n' >&2
+  exit 64
+fi
+
+cat "$ORCA_FIXTURE_DIR/$fixture"

package/internal/runner/orca/orcacli/testdata/terminal-close.json

@@ -0,0 +1,12 @@
+{
+  "id": "captured-terminal-close",
+  "ok": true,
+  "result": {
+    "close": {
+      "handle": "term-1",
+      "tabId": "tab-1",
+      "ptyKilled": true
+    }
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/terminal-create.json

@@ -0,0 +1,18 @@
+{
+  "id": "captured-terminal-create",
+  "ok": true,
+  "result": {
+    "terminal": {
+      "handle": "term-1",
+      "tabId": "tab-1",
+      "paneKey": "tab-1:leaf-1",
+      "ptyId": "wt-PAY-101@@pty-1",
+      "worktreeId": "wt-PAY-101",
+      "title": "PAY-101:implement",
+      "executionHostId": "local",
+      "hostPlatform": "linux",
+      "surface": "visible"
+    }
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/terminal-list.json

@@ -0,0 +1,51 @@
+{
+  "id": "captured-terminal-list",
+  "ok": true,
+  "result": {
+    "terminals": [
+      {
+        "handle": "term-1",
+        "ptyId": "wt-PAY-101@@pty-1",
+        "worktreeId": "wt-PAY-101",
+        "worktreePath": "/srv/worktrees/PAY-101",
+        "branch": "refs/heads/alice/PAY-101",
+        "tabId": "tab-1",
+        "leafId": "leaf-1",
+        "title": "opencode",
+        "connected": true,
+        "writable": true,
+        "preview": ""
+      }
+    ],
+    "visualLayouts": [
+      {
+        "worktreeId": "wt-PAY-101",
+        "worktreePath": "/srv/worktrees/PAY-101",
+        "root": {
+          "type": "group",
+          "groupId": "group-1",
+          "activeTabId": "tab-1",
+          "tabs": [
+            {
+              "tabId": "tab-1",
+              "title": "PAY-101:implement",
+              "activeLeafId": "leaf-1",
+              "panes": {
+                "type": "terminal",
+                "handle": "term-1",
+                "tabId": "tab-1",
+                "leafId": "leaf-1",
+                "title": "opencode",
+                "connected": true,
+                "active": true
+              }
+            }
+          ]
+        }
+      }
+    ],
+    "totalCount": 1,
+    "truncated": false
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/terminal-send.json

@@ -0,0 +1 @@
+{"ok":true,"result":{}}

package/internal/runner/orca/orcacli/testdata/terminal-show.json

@@ -0,0 +1 @@
+{"ok":true,"result":{"terminal":{"handle":"term-1","title":"PAY-101:implement","connected":true,"writable":true}}}

package/internal/runner/orca/orcacli/testdata/worktree-create.json

@@ -0,0 +1,22 @@
+{
+  "id": "captured-worktree-create",
+  "ok": true,
+  "result": {
+    "worktree": {
+      "id": "wt-PAY-101",
+      "instanceId": "instance-PAY-101",
+      "repoId": "repo-1",
+      "path": "/srv/worktrees/PAY-101",
+      "head": "0123456789abcdef",
+      "branch": "refs/heads/alice/PAY-101",
+      "isBare": false,
+      "isMainWorktree": false,
+      "displayName": "PAY-101",
+      "baseRef": "origin/alice/PAY-101",
+      "parentWorktreeId": "wt-main",
+      "childWorktreeIds": []
+    },
+    "warnings": []
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/worktree-list.json

@@ -0,0 +1,31 @@
+{
+  "id": "captured-worktree-list",
+  "ok": true,
+  "result": {
+    "worktrees": [
+      {
+        "id": "wt-main",
+        "instanceId": "instance-main",
+        "repoId": "repo-1",
+        "path": "/srv/app",
+        "head": "0123456789abcdef",
+        "branch": "refs/heads/master",
+        "isBare": false,
+        "isMainWorktree": true,
+        "displayName": "master",
+        "parentWorktreeId": null,
+        "childWorktreeIds": [],
+        "git": {
+          "path": "/srv/app",
+          "head": "0123456789abcdef",
+          "branch": "refs/heads/master",
+          "isBare": false,
+          "isMainWorktree": true
+        }
+      }
+    ],
+    "totalCount": 1,
+    "truncated": false
+  },
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/orca/orcacli/testdata/worktree-remove.json

@@ -0,0 +1,6 @@
+{
+  "id": "captured-worktree-remove",
+  "ok": true,
+  "result": {"removed": true},
+  "_meta": {"runtimeId": "runtime-1"}
+}

package/internal/runner/runner.go

@@ -1,81 +1,64 @@
-// 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 defines the runner contract: workspaces/environments,
+// terminals, liveness, and process handles. The runner does not know
+// task-system fields, workflow routes, report contents, or agent command
+// syntax.
 package runner
 
 import (
-	"fmt"
-	"sort"
-	"sync"
+	"context"
+	"errors"
 
-	"github.com/rajpopat27/relay-flow/internal/tasks"
+	"github.com/rajpopat27/relay-flow/internal/identity"
 )
 
-// Session is a live agent terminal/process handle.
-type Session struct {
-	ID    string
-	Title string
-}
+var ErrSessionUnavailable = errors.New("stored session unavailable")
 
-// 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
+type RepoCandidate struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
 }
 
-// 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)
+type Environment struct {
+	ID   string `json:"id"`
+	Path string `json:"path"`
 }
 
-var (
-	mu        sync.RWMutex
-	factories = map[string]Factory{}
-)
+type Terminal struct {
+	ID    string `json:"id"`
+	Title string `json:"title"`
+}
 
-// 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
+type Command struct {
+	Executable string            `json:"executable"`
+	Args       []string          `json:"args,omitempty"`
+	Env        map[string]string `json:"env,omitempty"`
 }
 
-// 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)
+type RunSpec struct {
+	RunID     identity.RunID
+	RepoName  string
+	RepoPath  string
+	TicketKey string
 }
 
-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
+// Runner owns ticket-scoped environments, terminals, and liveness.
+// FindTerminal returns only a live usable terminal. CloseTerminals closes
+// agent terminals while preserving the environment/workspace; CleanupRun
+// removes all runner-owned run resources at end. Both reconstruct identity
+// from RunSpec without SQLite IDs.
+//
+// Terminal titles are stable and minimal: only "<ticket>:<node>" — never
+// nodeVisitID, workflow name, agent name, or other changing metadata.
+type Runner interface {
+	DiscoverRepos(ctx context.Context) ([]RepoCandidate, error)
+	ValidateRepo(ctx context.Context, name, path string) error
+	EnsureEnvironment(ctx context.Context, spec RunSpec) (Environment, error)
+	InspectTerminal(ctx context.Context, terminal Terminal) (Terminal, bool, error)
+	SendTerminal(ctx context.Context, terminal Terminal, text string) error
+	CreateTerminal(ctx context.Context, env Environment, title string, command Command) (Terminal, error)
+	FindTerminal(ctx context.Context, env Environment, title string) (Terminal, bool, error)
+	CloseTerminal(ctx context.Context, terminal Terminal) error
+	EnsureTerminal(ctx context.Context, env Environment, title string, command Command) (Terminal, error)
+	CloseTerminals(ctx context.Context, spec RunSpec) error
+	CleanupRun(ctx context.Context, spec RunSpec) error
 }