preflight: if the repo has no remote, skip push & cleanup

This is useful for a pipeline that defines e.g. /path/to/codebase/.git
as the repository, with a buildkite-agent running on that local machine.
Changes to the that git repo don't need to be pushed anywhere.

Author: pda

cmd/preflight/preflight.go

@@ -151,7 +151,7 @@ func (c *PreflightCmd) Run(kongCtx *kong.Context, globals cli.GlobalFlags) error
 		}
 	}
 
-	if !c.NoCleanup {
+	if !c.NoCleanup && !result.PushSkipped {
 		fmt.Fprintf(os.Stderr, "Cleaning up remote branch %s...\n", result.Branch)
 		if cleanupErr := preflight.Cleanup(wt.Filesystem.Root(), result.Ref, globals.EnableDebug()); cleanupErr != nil {
 			fmt.Fprintf(os.Stderr, "Warning: failed to delete remote branch %s: %v\n", result.Ref, cleanupErr)

cmd/preflight/render.go

@@ -197,6 +197,9 @@ func snapshotLines(result *internalpreflight.SnapshotResult) []string {
 			lines = append(lines, fmt.Sprintf("  %s %s", file.StatusSymbol(), file.Path))
 		}
 	}
+	if result.PushSkipped {
+		lines = append(lines, "Warning: no remote \"origin\" found; push skipped")
+	}
 	return lines
 }
 

cmd/preflight/render_test.go

@@ -35,6 +35,18 @@ func TestTTYRenderer_SetSnapshot(t *testing.T) {
 	assertLineEquals(t, lines, "  - old/file.txt")
 }
 
+func TestTTYRenderer_SetSnapshot_WithWarning(t *testing.T) {
+	lines := captureTTYLines(t, func(r *ttyRenderer) {
+		r.setSnapshot(&internalpreflight.SnapshotResult{
+			Commit:      "1234567890abcdef",
+			Ref:         "refs/heads/bk/preflight/abc123",
+			PushSkipped: true,
+		})
+	})
+
+	assertLineContains(t, lines, "Warning:", "push skipped")
+}
+
 func TestTTYRenderer_RenderStatus_AllRunningJobs(t *testing.T) {
 	startedAt := buildkite.Timestamp{Time: time.Now().Add(-2 * time.Minute)}
 	lines := captureTTYLines(t, func(r *ttyRenderer) {

internal/preflight/snapshot.go

@@ -16,10 +16,11 @@ type FileChange struct {
 
 // SnapshotResult holds the output of a successful snapshot operation.
 type SnapshotResult struct {
-	Commit string
-	Ref    string
-	Branch string
-	Files  []FileChange
+	Commit      string
+	Ref         string
+	Branch      string
+	Files       []FileChange
+	PushSkipped bool
 }
 
 // StatusSymbol returns a human-readable symbol for the file change status.
@@ -111,17 +112,23 @@ func Snapshot(dir string, preflightID uuid.UUID, opts ...SnapshotOption) (*Snaps
 		}
 	}
 
-	// Push the commit to the remote branch.
-	refspec := fmt.Sprintf("%s:%s", commit, ref)
-	if err := gitRun(dir, env, cfg.debug, "push", "origin", refspec); err != nil {
-		return nil, err
+	var pushSkipped bool
+	if _, err := gitOutput(dir, env, cfg.debug, "remote", "get-url", "origin"); err != nil {
+		pushSkipped = true
+	} else {
+		// Push the commit to the remote branch.
+		refspec := fmt.Sprintf("%s:%s", commit, ref)
+		if err := gitRun(dir, env, cfg.debug, "push", "origin", refspec); err != nil {
+			return nil, err
+		}
 	}
 
 	return &SnapshotResult{
-		Commit: commit,
-		Ref:    ref,
-		Branch: branch,
-		Files:  files,
+		Commit:      commit,
+		Ref:         ref,
+		Branch:      branch,
+		Files:       files,
+		PushSkipped: pushSkipped,
 	}, nil
 }
 

internal/preflight/snapshot_test.go

@@ -326,6 +326,33 @@ func TestDiffFiles(t *testing.T) {
 	}
 }
 
+func TestSnapshot_NoRemote(t *testing.T) {
+	worktree := initTestRepo(t)
+
+	// Remove the origin remote.
+	runGit(t, worktree, "remote", "remove", "origin")
+
+	// Add a change so we exercise the commit path too.
+	if err := os.WriteFile(filepath.Join(worktree, "README.md"), []byte("# changed\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	preflightID := uuid.MustParse("00000000-0000-0000-0000-000000000010")
+	result, err := Snapshot(worktree, preflightID)
+	if err != nil {
+		t.Fatalf("Snapshot() error: %v", err)
+	}
+
+	if !result.PushSkipped {
+		t.Error("expected PushSkipped to be true when no remote exists")
+	}
+
+	// The commit should still be valid.
+	if len(result.Commit) != 40 {
+		t.Errorf("expected 40-char SHA, got %q", result.Commit)
+	}
+}
+
 func TestSnapshot_CleanWorktree(t *testing.T) {
 	worktree := initTestRepo(t)