relay-flow 0.2.3-alpha → 0.2.4-alpha

package/internal/runner/herdr/herdrcli/operations.go

@@ -0,0 +1,281 @@
+package herdrcli
+
+import "context"
+
+type workspaceResponse struct {
+	ID       string             `json:"workspace_id"`
+	Label    string             `json:"label"`
+	Worktree *worktreeRefwithID `json:"worktree"`
+}
+
+type worktreeRefwithID struct {
+	CheckoutPath string `json:"checkout_path"`
+	RepoName     string `json:"repo_name"`
+	RepoRoot     string `json:"repo_root"`
+	IsLinked     bool   `json:"is_linked_worktree"`
+}
+
+type worktreeResponse struct {
+	Path            string `json:"path"`
+	Branch          string `json:"branch"`
+	IsLinked        bool   `json:"is_linked_worktree"`
+	OpenWorkspaceID string `json:"open_workspace_id"`
+}
+
+type worktreeSourceResponse struct {
+	RepoName           string `json:"repo_name"`
+	RepoRoot           string `json:"repo_root"`
+	SourceCheckoutPath string `json:"source_checkout_path"`
+}
+
+type tabResponse struct {
+	ID          string `json:"tab_id"`
+	WorkspaceID string `json:"workspace_id"`
+	Label       string `json:"label"`
+}
+
+type paneResponse struct {
+	ID          string `json:"pane_id"`
+	TerminalID  string `json:"terminal_id"`
+	WorkspaceID string `json:"workspace_id"`
+	TabID       string `json:"tab_id"`
+	Label       string `json:"label"`
+	CWD         string `json:"cwd"`
+}
+
+type processInfoResponse struct {
+	PaneID              string                      `json:"pane_id"`
+	ShellPID            *uint32                     `json:"shell_pid"`
+	ForegroundProcesses []foregroundProcessResponse `json:"foreground_processes"`
+}
+
+type foregroundProcessResponse struct {
+	PID  uint32 `json:"pid"`
+	Name string `json:"name"`
+}
+
+func (c *CLI) Snapshot(ctx context.Context) (Snapshot, error) {
+	var response struct {
+		Snapshot struct {
+			Workspaces []workspaceResponse `json:"workspaces"`
+			Tabs       []tabResponse       `json:"tabs"`
+			Panes      []paneResponse      `json:"panes"`
+		} `json:"snapshot"`
+	}
+	if err := c.runJSON(ctx, "api snapshot", &response, "api", "snapshot"); err != nil {
+		return Snapshot{}, err
+	}
+	return Snapshot{
+		Workspaces: convertWorkspaces(response.Snapshot.Workspaces),
+		Tabs:       convertTabs(response.Snapshot.Tabs),
+		Panes:      convertPanes(response.Snapshot.Panes),
+	}, nil
+}
+
+func (c *CLI) WorktreeList(ctx context.Context, repoPath string) (WorktreeListing, error) {
+	var response struct {
+		Source    worktreeSourceResponse `json:"source"`
+		Worktrees []worktreeResponse     `json:"worktrees"`
+	}
+	if err := c.runJSON(ctx, "worktree list", &response, "worktree", "list", "--cwd", repoPath); err != nil {
+		return WorktreeListing{}, err
+	}
+	return WorktreeListing{
+		Source: WorktreeSource{
+			RepoName:           response.Source.RepoName,
+			RepoRoot:           response.Source.RepoRoot,
+			SourceCheckoutPath: response.Source.SourceCheckoutPath,
+		},
+		Worktrees: convertWorktrees(response.Worktrees),
+	}, nil
+}
+
+// WorktreeCreate creates the ticket branch checkout and opens it as its own
+// workspace. Herdr reuses an existing branch, so base applies only when the
+// branch does not exist yet and prior agent commits are never discarded.
+func (c *CLI) WorktreeCreate(ctx context.Context, repoPath, branch, base, label string) (Workspace, error) {
+	args := []string{
+		"worktree", "create",
+		"--cwd", repoPath,
+		"--branch", branch,
+		"--base", base,
+		"--label", label,
+		"--no-focus",
+	}
+	return c.workspaceFromWorktree(ctx, "worktree create", args)
+}
+
+// WorktreeOpen opens the existing ticket checkout, reusing the workspace when
+// it is already open. It returns ErrWorktreeNotFound when no checkout exists
+// for the branch.
+func (c *CLI) WorktreeOpen(ctx context.Context, repoPath, branch, label string) (Workspace, error) {
+	args := []string{
+		"worktree", "open",
+		"--cwd", repoPath,
+		"--branch", branch,
+		"--label", label,
+		"--no-focus",
+	}
+	return c.workspaceFromWorktree(ctx, "worktree open", args)
+}
+
+func (c *CLI) workspaceFromWorktree(ctx context.Context, operation string, args []string) (Workspace, error) {
+	var response struct {
+		Workspace workspaceResponse `json:"workspace"`
+	}
+	if err := c.runJSON(ctx, operation, &response, args...); err != nil {
+		return Workspace{}, err
+	}
+	return convertWorkspace(response.Workspace), nil
+}
+
+func (c *CLI) CreateTab(ctx context.Context, workspaceID, cwd, label string) (Tab, Pane, error) {
+	args := []string{
+		"tab", "create",
+		"--workspace", workspaceID,
+		"--cwd", cwd,
+		"--label", label,
+		"--no-focus",
+	}
+	var response struct {
+		Tab      tabResponse  `json:"tab"`
+		RootPane paneResponse `json:"root_pane"`
+	}
+	if err := c.runJSON(ctx, "tab create", &response, args...); err != nil {
+		return Tab{}, Pane{}, err
+	}
+	return convertTab(response.Tab), convertPane(response.RootPane), nil
+}
+
+func (c *CLI) ListTabs(ctx context.Context, workspaceID string) ([]Tab, error) {
+	var response struct {
+		Tabs []tabResponse `json:"tabs"`
+	}
+	if err := c.runJSON(ctx, "tab list", &response, "tab", "list", "--workspace", workspaceID); err != nil {
+		return nil, err
+	}
+	return convertTabs(response.Tabs), nil
+}
+
+func (c *CLI) ListPanes(ctx context.Context, workspaceID string) ([]Pane, error) {
+	var response struct {
+		Panes []paneResponse `json:"panes"`
+	}
+	if err := c.runJSON(ctx, "pane list", &response, "pane", "list", "--workspace", workspaceID); err != nil {
+		return nil, err
+	}
+	return convertPanes(response.Panes), nil
+}
+
+func (c *CLI) GetPane(ctx context.Context, paneID string) (Pane, error) {
+	var response struct {
+		Pane paneResponse `json:"pane"`
+	}
+	if err := c.runJSON(ctx, "pane get", &response, "pane", "get", paneID); err != nil {
+		return Pane{}, err
+	}
+	return convertPane(response.Pane), nil
+}
+
+func (c *CLI) ProcessInfo(ctx context.Context, paneID string) (ProcessInfo, error) {
+	var response struct {
+		ProcessInfo processInfoResponse `json:"process_info"`
+	}
+	if err := c.runJSON(ctx, "pane process-info", &response, "pane", "process-info", "--pane", paneID); err != nil {
+		return ProcessInfo{}, err
+	}
+	return convertProcessInfo(response.ProcessInfo), nil
+}
+
+func (c *CLI) RenamePane(ctx context.Context, paneID, label string) error {
+	return c.runCommand(ctx, "pane rename", "pane", "rename", paneID, label)
+}
+
+func (c *CLI) RunPane(ctx context.Context, paneID, command string) error {
+	return c.runCommand(ctx, "pane run", "pane", "run", paneID, command)
+}
+
+func (c *CLI) ClosePane(ctx context.Context, paneID string) error {
+	return c.runCommand(ctx, "pane close", "pane", "close", paneID)
+}
+
+func (c *CLI) CloseWorkspace(ctx context.Context, workspaceID string) error {
+	return c.runCommand(ctx, "workspace close", "workspace", "close", workspaceID)
+}
+
+func convertWorkspace(value workspaceResponse) Workspace {
+	workspace := Workspace{ID: value.ID, Label: value.Label}
+	if value.Worktree != nil {
+		workspace.Worktree = WorkspaceWorktree{
+			CheckoutPath: value.Worktree.CheckoutPath,
+			RepoName:     value.Worktree.RepoName,
+			RepoRoot:     value.Worktree.RepoRoot,
+			IsLinked:     value.Worktree.IsLinked,
+		}
+	}
+	return workspace
+}
+
+func convertWorkspaces(values []workspaceResponse) []Workspace {
+	out := make([]Workspace, len(values))
+	for i, value := range values {
+		out[i] = convertWorkspace(value)
+	}
+	return out
+}
+
+func convertWorktrees(values []worktreeResponse) []Worktree {
+	out := make([]Worktree, len(values))
+	for i, value := range values {
+		out[i] = Worktree{
+			Path:            value.Path,
+			Branch:          value.Branch,
+			IsLinked:        value.IsLinked,
+			OpenWorkspaceID: value.OpenWorkspaceID,
+		}
+	}
+	return out
+}
+
+func convertTab(value tabResponse) Tab {
+	return Tab{ID: value.ID, WorkspaceID: value.WorkspaceID, Label: value.Label}
+}
+
+func convertTabs(values []tabResponse) []Tab {
+	out := make([]Tab, len(values))
+	for i, value := range values {
+		out[i] = convertTab(value)
+	}
+	return out
+}
+
+func convertPane(value paneResponse) Pane {
+	return Pane{
+		ID:          value.ID,
+		TerminalID:  value.TerminalID,
+		WorkspaceID: value.WorkspaceID,
+		TabID:       value.TabID,
+		Label:       value.Label,
+		CWD:         value.CWD,
+	}
+}
+
+func convertPanes(values []paneResponse) []Pane {
+	out := make([]Pane, len(values))
+	for i, value := range values {
+		out[i] = convertPane(value)
+	}
+	return out
+}
+
+func convertProcessInfo(value processInfoResponse) ProcessInfo {
+	processes := make([]ForegroundProcess, len(value.ForegroundProcesses))
+	for i, process := range value.ForegroundProcesses {
+		processes[i] = ForegroundProcess{PID: process.PID, Name: process.Name}
+	}
+	return ProcessInfo{
+		PaneID:              value.PaneID,
+		ShellPID:            value.ShellPID,
+		ForegroundProcesses: processes,
+	}
+}

package/internal/runner/herdr/herdrcli/response.go

@@ -0,0 +1,116 @@
+package herdrcli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Observed Herdr transport contract (herdr 0.8.2, protocol 20):
+//
+//	success: JSON envelope {"id":...,"result":{...}} on stdout, exit 0.
+//	         pane run writes nothing on either stream.
+//	failure: JSON envelope {"id":...,"error":{"code","message"}} on stderr,
+//	         exit 1, empty stdout.
+//
+// There is no "ok" field; presence of result/error is the contract.
+type responseEnvelope struct {
+	Result json.RawMessage `json:"result"`
+	Error  *apiError       `json:"error"`
+}
+
+type apiError struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+func sentinelFor(code string) error {
+	switch code {
+	case "pane_not_found":
+		return ErrPaneNotFound
+	case "workspace_not_found":
+		return ErrWorkspaceNotFound
+	case "worktree_not_found":
+		return ErrWorktreeNotFound
+	case "not_git_worktree":
+		return ErrNotGitWorktree
+	default:
+		return nil
+	}
+}
+
+// runJSON executes an operation that returns a result body and unmarshals it
+// into dest. Command arguments can contain prompts, so failures report only
+// the operation name and Herdr's own message.
+func (c *CLI) runJSON(ctx context.Context, operation string, dest any, args ...string) error {
+	stdout, stderr, err := c.execute(ctx, args...)
+	if apiErr := decodeError(operation, stderr); apiErr != nil {
+		return apiErr
+	}
+	if err != nil {
+		return commandError(operation, stderr, err)
+	}
+	return decodeResult(operation, stdout, dest)
+}
+
+// runCommand executes a mutating operation. Herdr returns either an "ok"
+// result body or no body at all; only the error envelope matters.
+func (c *CLI) runCommand(ctx context.Context, operation string, args ...string) error {
+	_, stderr, err := c.execute(ctx, args...)
+	if apiErr := decodeError(operation, stderr); apiErr != nil {
+		return apiErr
+	}
+	if err != nil {
+		return commandError(operation, stderr, err)
+	}
+	return nil
+}
+
+// decodeError converts a Herdr error envelope on stderr into a typed error.
+// Non-JSON stderr is not an error by itself; Herdr also uses stderr for
+// warnings.
+func decodeError(operation string, stderr []byte) error {
+	trimmed := bytes.TrimSpace(stderr)
+	if len(trimmed) == 0 || trimmed[0] != '{' {
+		return nil
+	}
+	var envelope responseEnvelope
+	if err := json.Unmarshal(trimmed, &envelope); err != nil || envelope.Error == nil {
+		return nil
+	}
+	message := envelope.Error.Message
+	if message == "" {
+		message = envelope.Error.Code
+	}
+	if sentinel := sentinelFor(envelope.Error.Code); sentinel != nil {
+		return fmt.Errorf("herdr %s: %s: %w", operation, message, sentinel)
+	}
+	return fmt.Errorf("herdr %s: %s (%s)", operation, message, envelope.Error.Code)
+}
+
+func decodeResult(operation string, stdout []byte, dest any) error {
+	if dest == nil {
+		return nil
+	}
+	var envelope responseEnvelope
+	if err := json.Unmarshal(stdout, &envelope); err != nil {
+		return fmt.Errorf("herdr %s: malformed JSON response: %w", operation, err)
+	}
+	if len(bytes.TrimSpace(envelope.Result)) == 0 {
+		return fmt.Errorf("herdr %s: response missing result", operation)
+	}
+	if err := json.Unmarshal(envelope.Result, dest); err != nil {
+		return fmt.Errorf("herdr %s: malformed result: %w", operation, err)
+	}
+	return nil
+}
+
+func commandError(operation string, stderr []byte, commandErr error) error {
+	message := strings.TrimSpace(string(stderr))
+	if message == "" {
+		return fmt.Errorf("herdr %s: command failed: %w", operation, commandErr)
+	}
+	return fmt.Errorf("herdr %s: command failed: %w: %s", operation, commandErr, message)
+}

package/internal/runner/herdr/herdrcli/testdata/empty-panes.json

@@ -0,0 +1 @@
+{"id":"cli:pane:list","result":{"panes":[],"type":"pane_list"}}

package/internal/runner/herdr/herdrcli/testdata/empty-tabs.json

@@ -0,0 +1 @@
+{"id":"cli:tab:list","result":{"tabs":[],"type":"tab_list"}}

package/internal/runner/herdr/herdrcli/testdata/error-not-git-worktree.json

@@ -0,0 +1 @@
+{"error":{"code":"not_git_worktree","message":"Herdr worktree actions require a path inside a Git work tree"},"id":"cli:worktree:list"}

package/internal/runner/herdr/herdrcli/testdata/error-pane-not-found.json

@@ -0,0 +1 @@
+{"error":{"code":"pane_not_found","message":"pane w9:p9 not found"},"id":"cli:pane:get"}

package/internal/runner/herdr/herdrcli/testdata/error-workspace-not-found.json

@@ -0,0 +1 @@
+{"error":{"code":"workspace_not_found","message":"workspace w9 not found"},"id":"cli:tab:list"}

package/internal/runner/herdr/herdrcli/testdata/error-worktree-not-found.json

@@ -0,0 +1 @@
+{"error":{"code":"worktree_not_found","message":"worktree branch not found"},"id":"cli:worktree:open"}

package/internal/runner/herdr/herdrcli/testdata/malformed.json

@@ -0,0 +1 @@
+{"id":"cli:pane:get","result":{"pane":

package/internal/runner/herdr/herdrcli/testdata/pane-close.json

@@ -0,0 +1,6 @@
+{
+  "id": "cli:pane:close",
+  "result": {
+    "type": "ok"
+  }
+}

package/internal/runner/herdr/herdrcli/testdata/pane-get.json

@@ -0,0 +1,25 @@
+{
+  "id": "cli:pane:get",
+  "result": {
+    "pane": {
+      "agent_status": "unknown",
+      "cwd": "/work/worktrees/payments/pay-101",
+      "focused": false,
+      "foreground_cwd": "/work/worktrees/payments/pay-101",
+      "label": "PAY-101:coding",
+      "pane_id": "w2:p2",
+      "revision": 2,
+      "scroll": {
+        "max_offset_from_bottom": 0,
+        "offset_from_bottom": 0,
+        "viewport_rows": 39
+      },
+      "tab_id": "w2:t2",
+      "terminal_id": "term_65a5cfcc913e03",
+      "terminal_title": "sleep 300",
+      "terminal_title_stripped": "sleep 300",
+      "workspace_id": "w2"
+    },
+    "type": "pane_info"
+  }
+}

package/internal/runner/herdr/herdrcli/testdata/pane-list.json

@@ -0,0 +1,45 @@
+{
+  "id": "cli:pane:list",
+  "result": {
+    "panes": [
+      {
+        "agent_status": "unknown",
+        "cwd": "/work/worktrees/payments/pay-101",
+        "focused": false,
+        "foreground_cwd": "/work/worktrees/payments/pay-101",
+        "pane_id": "w2:p1",
+        "revision": 1,
+        "scroll": {
+          "max_offset_from_bottom": 0,
+          "offset_from_bottom": 0,
+          "viewport_rows": 39
+        },
+        "tab_id": "w2:t1",
+        "terminal_id": "term_65a5cfcc8cd9e2",
+        "terminal_title": "relay@relay-host:~/.herdr/worktrees/repo/pay-101",
+        "terminal_title_stripped": "relay@relay-host:~/.herdr/worktrees/repo/pay-101",
+        "workspace_id": "w2"
+      },
+      {
+        "agent_status": "unknown",
+        "cwd": "/work/worktrees/payments/pay-101",
+        "focused": false,
+        "foreground_cwd": "/work/worktrees/payments/pay-101",
+        "label": "PAY-101:coding",
+        "pane_id": "w2:p2",
+        "revision": 2,
+        "scroll": {
+          "max_offset_from_bottom": 0,
+          "offset_from_bottom": 0,
+          "viewport_rows": 39
+        },
+        "tab_id": "w2:t2",
+        "terminal_id": "term_65a5cfcc913e03",
+        "terminal_title": "sleep 300",
+        "terminal_title_stripped": "sleep 300",
+        "workspace_id": "w2"
+      }
+    ],
+    "type": "pane_list"
+  }
+}

package/internal/runner/herdr/herdrcli/testdata/pane-process-info-shell.json

@@ -0,0 +1,22 @@
+{
+  "id": "cli:pane:process_info",
+  "result": {
+    "process_info": {
+      "foreground_process_group_id": 466928,
+      "foreground_processes": [
+        {
+          "argv": [
+            "/usr/bin/zsh"
+          ],
+          "cmdline": "/usr/bin/zsh",
+          "cwd": "/work/worktrees/payments/pay-101",
+          "name": "zsh",
+          "pid": 466928
+        }
+      ],
+      "pane_id": "w2:p3",
+      "shell_pid": 466928
+    },
+    "type": "pane_process_info"
+  }
+}

package/internal/runner/herdr/herdrcli/testdata/pane-process-info.json

@@ -0,0 +1,23 @@
+{
+  "id": "cli:pane:process_info",
+  "result": {
+    "process_info": {
+      "foreground_process_group_id": 466891,
+      "foreground_processes": [
+        {
+          "argv": [
+            "sleep",
+            "300"
+          ],
+          "cmdline": "sleep 300",
+          "cwd": "/work/worktrees/payments/pay-101",
+          "name": "sleep",
+          "pid": 466891
+        }
+      ],
+      "pane_id": "w2:p2",
+      "shell_pid": 466344
+    },
+    "type": "pane_process_info"
+  }
+}

package/internal/runner/herdr/herdrcli/testdata/pane-rename.json

@@ -0,0 +1,23 @@
+{
+  "id": "cli:pane:rename",
+  "result": {
+    "pane": {
+      "agent_status": "unknown",
+      "cwd": "/work/worktrees/payments/pay-101",
+      "focused": false,
+      "foreground_cwd": "/work/worktrees/payments/pay-101",
+      "label": "PAY-101:coding",
+      "pane_id": "w2:p2",
+      "revision": 0,
+      "scroll": {
+        "max_offset_from_bottom": 0,
+        "offset_from_bottom": 0,
+        "viewport_rows": 39
+      },
+      "tab_id": "w2:t2",
+      "terminal_id": "term_65a5cfcc913e03",
+      "workspace_id": "w2"
+    },
+    "type": "pane_info"
+  }
+}