fix: add git cli fallbacks for linked worktrees (#751)

* fix(git): fall back to git cli for worktree repos
* fix: add git cli repo root fallback
* Update internal/build/resolver/options/options_test.go

Co-authored-by: Ben McNicholl <ben.mcnicholl@buildkite.com>

* Update cmd/preflight/preflight.go

Co-authored-by: Ben McNicholl <ben.mcnicholl@buildkite.com>

* fix(test): import os in branch fallback test

* refactor: simplify git remote fallback

---------

Co-authored-by: Ben McNicholl <ben.mcnicholl@buildkite.com>

Author: lox

cmd/preflight/preflight.go

@@ -33,14 +33,17 @@ type PreflightCmd struct {
 	JSON      bool    `help:"Emit one JSON object per event (JSONL)." xor:"output"`
 }
 
-var notifyContext = signal.NotifyContext
+var (
+	notifyContext = signal.NotifyContext
+	newFactory    = factory.New
+)
 
 func (c *PreflightCmd) Help() string {
 	return `Snapshots your working tree (uncommitted, staged, and untracked changes) and pushes it to a bk/preflight/<id> branch. If there are no local changes, pushes HEAD directly.`
 }
 
 func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error {
-	f, err := factory.New(factory.WithDebug(globals.EnableDebug()))
+	f, err := newFactory(factory.WithDebug(globals.EnableDebug()))
 	if err != nil {
 		return bkErrors.NewInternalError(err, "failed to initialize CLI", "This is likely a bug", "Report to Buildkite")
 	}
@@ -51,19 +54,15 @@ func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error
 			"the preflight command is under development and requires the 'preflight' experiment to opt in. Run: bk config set experiments preflight or set BUILDKITE_EXPERIMENTS=preflight")
 	}
 
-	if f.GitRepository == nil {
+	repoRoot, err := resolveRepositoryRoot(f, globals.EnableDebug())
+	if err != nil {
 		return bkErrors.NewValidationError(
-			fmt.Errorf("not in a git repository"),
+			fmt.Errorf("not in a git repository: %w", err),
 			"preflight must be run from a git repository",
 			"Run this command from inside a git repository",
 		)
 	}
 
-	wt, err := f.GitRepository.Worktree()
-	if err != nil {
-		return bkErrors.NewInternalError(err, "failed to get git worktree")
-	}
-
 	preflightID, err := uuid.NewV7()
 	if err != nil {
 		return bkErrors.NewInternalError(err, "UUIDv7 generation failed")
@@ -97,7 +96,7 @@ func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error
 		opts = append(opts, preflight.WithDebug())
 	}
 
-	result, err := preflight.Snapshot(wt.Filesystem.Root(), preflightID, opts...)
+	result, err := preflight.Snapshot(repoRoot, preflightID, opts...)
 	if err != nil {
 		return bkErrors.NewSnapshotError(err, "failed to create preflight snapshot",
 			"Ensure you have uncommitted or committed changes to snapshot",
@@ -170,7 +169,7 @@ func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error
 
 	if !c.NoCleanup {
 		_ = renderer.Render(Event{Type: EventOperation, Time: time.Now(), PreflightID: preflightID.String(), Title: fmt.Sprintf("Cleaning up remote branch %s...", result.Branch)})
-		if cleanupErr := preflight.Cleanup(wt.Filesystem.Root(), result.Ref, globals.EnableDebug()); cleanupErr != nil {
+		if cleanupErr := preflight.Cleanup(repoRoot, result.Ref, globals.EnableDebug()); cleanupErr != nil {
 			_ = renderer.Render(Event{Type: EventOperation, Time: time.Now(), PreflightID: preflightID.String(), Title: fmt.Sprintf("Warning: failed to delete remote branch %s: %v", result.Ref, cleanupErr)})
 		} else {
 			_ = renderer.Render(Event{Type: EventOperation, Time: time.Now(), PreflightID: preflightID.String(), Title: fmt.Sprintf("Deleted remote branch %s", result.Branch)})
@@ -208,3 +207,14 @@ func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error
 
 	return finalErr
 }
+
+func resolveRepositoryRoot(f *factory.Factory, debug bool) (string, error) {
+	if f.GitRepository != nil {
+		wt, err := f.GitRepository.Worktree()
+		if err == nil {
+			return wt.Filesystem.Root(), nil
+		}
+	}
+
+	return preflight.RepositoryRoot(".", debug)
+}

cmd/preflight/preflight_test.go

@@ -14,12 +14,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/buildkite/cli/v3/internal/config"
 	buildkite "github.com/buildkite/go-buildkite/v4"
 
 	"github.com/buildkite/cli/v3/internal/build/watch"
 	bkErrors "github.com/buildkite/cli/v3/internal/errors"
 
 	"github.com/buildkite/cli/v3/internal/cli"
+	"github.com/buildkite/cli/v3/pkg/cmd/factory"
 )
 
 type stubGlobals struct{}
@@ -125,6 +127,67 @@ func TestPreflightCmd_Run(t *testing.T) {
 		}
 	})
 
+	t.Run("falls back to git cli when factory cannot open repository", func(t *testing.T) {
+		t.Setenv("BUILDKITE_EXPERIMENTS", "preflight")
+
+		originalNewFactory := newFactory
+		t.Cleanup(func() { newFactory = originalNewFactory })
+
+		now := time.Now()
+		s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			switch {
+			case r.Method == "POST" && strings.Contains(r.URL.Path, "/builds"):
+				json.NewEncoder(w).Encode(buildkite.Build{
+					Number: 1,
+					State:  "scheduled",
+					WebURL: "https://buildkite.com/test-org/test-pipeline/builds/1",
+				})
+				return
+			case r.Method == "GET" && strings.Contains(r.URL.Path, "/builds/1"):
+				json.NewEncoder(w).Encode(buildkite.Build{
+					Number:     1,
+					State:      "passed",
+					FinishedAt: &buildkite.Timestamp{Time: now},
+				})
+				return
+			}
+			http.NotFound(w, r)
+		}))
+		defer s.Close()
+
+		newFactory = func(...factory.FactoryOpt) (*factory.Factory, error) {
+			client, err := buildkite.NewOpts(buildkite.WithBaseURL(s.URL))
+			if err != nil {
+				return nil, err
+			}
+			return &factory.Factory{
+				Config:        config.New(nil, nil),
+				RestAPIClient: client,
+			}, nil
+		}
+
+		worktree := initTestRepo(t)
+		subdir := filepath.Join(worktree, "nested", "dir")
+		if err := os.MkdirAll(subdir, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		t.Chdir(subdir)
+		if err := os.WriteFile(filepath.Join(subdir, "new.txt"), []byte("hello\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+
+		cmd := &PreflightCmd{Pipeline: "test-org/test-pipeline", Watch: true, Interval: 0.01}
+		if err := cmd.Run(nil, stubGlobals{}); err != nil {
+			t.Fatalf("expected no error, got: %v", err)
+		}
+
+		refs := runGit(t, worktree, "ls-remote", "--heads", "origin")
+		if strings.Contains(refs, "bk/preflight/") {
+			t.Errorf("expected preflight branch to be cleaned up, but found: %s", refs)
+		}
+	})
+
 	t.Run("watches build until completion and cleans up remote branch", func(t *testing.T) {
 		t.Setenv("BUILDKITE_EXPERIMENTS", "preflight")
 

internal/build/resolver/options/options.go

@@ -2,6 +2,9 @@ package options
 
 import (
 	"context"
+	"errors"
+	"os/exec"
+	"strings"
 
 	"github.com/buildkite/cli/v3/pkg/cmd/factory"
 	buildkite "github.com/buildkite/go-buildkite/v4"
@@ -33,19 +36,45 @@ func ResolveBranchFromFlag(branch string) OptionsFn {
 // ResolveBranchFromRepository returns a function that is used to add a branch filter to a build list options
 func ResolveBranchFromRepository(repo *git.Repository) OptionsFn {
 	return func(options *buildkite.BuildsListOptions) error {
-		var branch string
-		if repo != nil && len(options.Branch) == 0 {
+		if len(options.Branch) > 0 {
+			return nil
+		}
+
+		if repo != nil {
 			head, err := repo.Head()
 			if err != nil {
 				return err
 			}
-			branch = head.Name().Short()
+			options.Branch = append(options.Branch, head.Name().Short())
+			return nil
+		}
+
+		branch, err := getBranchFromGit()
+		if err != nil {
+			return err
+		}
+		if branch != "" {
 			options.Branch = append(options.Branch, branch)
 		}
 		return nil
 	}
 }
 
+func getBranchFromGit() (string, error) {
+	cmd := exec.Command("git", "symbolic-ref", "--quiet", "--short", "HEAD")
+	output, err := cmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		var execErr *exec.Error
+		if errors.As(err, &exitErr) || errors.As(err, &execErr) {
+			return "", nil
+		}
+		return "", err
+	}
+
+	return strings.TrimSpace(string(output)), nil
+}
+
 // ResolveUserFromFlag returns a function that is used to add a user filter to a build list options
 func ResolveUserFromFlag(user string) OptionsFn {
 	return func(options *buildkite.BuildsListOptions) error {

internal/build/resolver/options/options_test.go

@@ -0,0 +1,67 @@
+package options
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	buildkite "github.com/buildkite/go-buildkite/v4"
+	git "github.com/go-git/go-git/v5"
+	gitconfig "github.com/go-git/go-git/v5/config"
+)
+
+func TestResolveBranchFromGitFallback(t *testing.T) {
+	repo := testRepository(t, "https://github.com/buildkite/cli.git")
+	wt, err := repo.Worktree()
+	if err != nil {
+		t.Fatalf("Worktree returned error: %v", err)
+	}
+	root := wt.Filesystem.Root()
+	t.Chdir(root)
+
+	commitFile := filepath.Join(root, "README.md")
+	if err := os.WriteFile(filepath.Join(root, "README.md"), []byte("hello\n"), 0o644); err != nil {
+		t.Fatalf("creating file returned error: %v", err)
+	}
+	if err := exec.Command("git", "add", filepath.Base(commitFile)).Run(); err != nil {
+		t.Fatalf("git add returned error: %v", err)
+	}
+	if err := exec.Command("git", "-c", "user.name=Person Example", "-c", "user.email=person@example.com", "commit", "-m", "initial").Run(); err != nil {
+		t.Fatalf("git commit returned error: %v", err)
+	}
+	if err := exec.Command("git", "checkout", "-b", "feature/test").Run(); err != nil {
+		t.Fatalf("git checkout returned error: %v", err)
+	}
+
+	options := &buildkite.BuildsListOptions{}
+	err = ResolveBranchFromRepository(nil)(options)
+	if err != nil {
+		t.Fatalf("ResolveBranchFromRepository returned error: %v", err)
+	}
+	if len(options.Branch) != 1 {
+		t.Fatalf("expected 1 branch, got %d", len(options.Branch))
+	}
+	if options.Branch[0] != "feature/test" {
+		t.Fatalf("expected branch feature/test, got %q", options.Branch[0])
+	}
+}
+
+func testRepository(t *testing.T, remoteURLs ...string) *git.Repository {
+	t.Helper()
+
+	repo, err := git.PlainInit(t.TempDir(), false)
+	if err != nil {
+		t.Fatalf("PlainInit returned error: %v", err)
+	}
+	if len(remoteURLs) == 0 {
+		return repo
+	}
+
+	_, err = repo.CreateRemote(&gitconfig.RemoteConfig{Name: "origin", URLs: remoteURLs})
+	if err != nil {
+		t.Fatalf("CreateRemote returned error: %v", err)
+	}
+
+	return repo
+}

internal/pipeline/resolver/repository.go

@@ -2,6 +2,8 @@ package resolver
 
 import (
 	"context"
+	"errors"
+	"os/exec"
 	"strings"
 
 	bkIO "github.com/buildkite/cli/v3/internal/io"
@@ -52,6 +54,12 @@ func resolveFromRepository(ctx context.Context, f *factory.Factory, org string)
 	if err != nil {
 		return nil, err
 	}
+	if len(repos) == 0 {
+		repos, err = getRepoURLsFromGit(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
 	return filterPipelines(ctx, repos, org, f.RestAPIClient)
 }
 
@@ -106,3 +114,27 @@ func getRepoURLs(r *git.Repository) ([]string, error) {
 	}
 	return c.Remotes["origin"].URLs, nil
 }
+
+func getRepoURLsFromGit(ctx context.Context) ([]string, error) {
+	cmd := exec.CommandContext(ctx, "git", "remote", "get-url", "--all", "origin")
+	output, err := cmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		var execErr *exec.Error
+		if errors.As(err, &exitErr) || errors.As(err, &execErr) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	var urls []string
+	for _, line := range strings.Split(string(output), "\n") {
+		url := strings.TrimSpace(line)
+		if url == "" {
+			continue
+		}
+		urls = append(urls, url)
+	}
+
+	return urls, nil
+}

internal/pipeline/resolver/repository_test.go

@@ -96,6 +96,33 @@ func TestResolvePipelinesFromPath(t *testing.T) {
 	})
 }
 
+func TestResolvePipelinesFromGitFallback(t *testing.T) {
+	ctx := context.Background()
+	const testOrg = "testOrg"
+
+	s := mockHTTPServer(`[{"slug": "cli-resolver-smoke", "repository": "git@github.com:buildkite/cli.git"}]`)
+	t.Cleanup(s.Close)
+
+	repo := testRepository(t, "https://github.com/buildkite/cli.git")
+	wt, err := repo.Worktree()
+	if err != nil {
+		t.Fatalf("Worktree returned error: %v", err)
+	}
+	t.Chdir(wt.Filesystem.Root())
+
+	f := testFactory(t, s.URL, testOrg, nil)
+	pipelines, err := resolveFromRepository(ctx, f, testOrg)
+	if err != nil {
+		t.Errorf("Error: %s", err)
+	}
+	if len(pipelines) != 1 {
+		t.Errorf("Expected 1 pipeline, got %d", len(pipelines))
+	}
+	if len(pipelines) == 1 && pipelines[0].Name != "cli-resolver-smoke" {
+		t.Errorf("Expected cli-resolver-smoke pipeline, got %s", pipelines[0].Name)
+	}
+}
+
 func testRepository(t *testing.T, remoteURLs ...string) *git.Repository {
 	t.Helper()
 

internal/preflight/git.go

@@ -41,3 +41,8 @@ func gitOutput(dir string, env []string, debug bool, args ...string) (string, er
 	}
 	return strings.TrimSpace(string(out)), nil
 }
+
+// RepositoryRoot returns the top-level path for the git repository containing dir.
+func RepositoryRoot(dir string, debug bool) (string, error) {
+	return gitOutput(dir, nil, debug, "rev-parse", "--show-toplevel")
+}