runner: fallback when git extensions are unsupported (#1074)

## Summary
- add a `project.WithAllowUnsupportedGitExtensions` option for
`NewDirProject`
- when enabled, fall back to plain directory mode if go-git fails on
unsupported repository extensions
- enable this option in runner v2 project conversion so startup sessions
do not fail in repos with `extensions.worktreeConfig`
- add a focused test that reproduces unsupported extension behavior and
verifies fallback

## Testing
- go test ./project -run
'^TestNewDirProject_FallbackOnUnsupportedGitExtensions$'
- go test ./runnerv2service -run
'^TestRunnerServiceServerCreateSession$'
- go test ./pkg/agent/server

## Notes
- `go test ./project` fails in this local environment because `direnv`
is not installed; unchanged pre-existing dependency in project tests.

---------

Signed-off-by: Jeremy lewi <jeremy@lewi.us>

Author: jlewi

cmd/common.go

@@ -85,6 +85,8 @@ func getProjectWithEnvDir(enabled bool) (*project.Project, error) {
 			opts = append(opts, project.WithEnvFilesReadOrder(fEnvOrder))
 		}
 
+		opts = append(opts, project.WithAllowUnsupportedGitExtensions(true))
+
 		var err error
 		proj, err = project.NewDirProject(projDir, opts...)
 		if err != nil {

internal/config/autoconfig/autoconfig.go

@@ -219,6 +219,8 @@ func getProject(c *config.Config, logger *zap.Logger) (*project.Project, error)
 		opts = append(opts, project.WithFindRepoUpward())
 	}
 
+	opts = append(opts, project.WithAllowUnsupportedGitExtensions(true))
+
 	return project.NewDirProject(projDir, opts...)
 }
 

project/project.go

@@ -127,6 +127,15 @@ func WithLogger(logger *zap.Logger) ProjectOption {
 	}
 }
 
+// WithAllowUnsupportedGitExtensions configures NewDirProject to continue in
+// plain directory mode when go-git can't open a repository due to unsupported
+// repository extensions.
+func WithAllowUnsupportedGitExtensions(value bool) ProjectOption {
+	return func(p *Project) {
+		p.allowUnsupportedGitExtensions = value
+	}
+}
+
 type Project struct {
 	// filePath is used for file-based projects.
 	filePath string
@@ -143,6 +152,9 @@ type Project struct {
 	repo             *git.Repository
 	plainOpenOptions *git.PlainOpenOptions
 	respectGitignore bool
+	// allowUnsupportedGitExtensions keeps project initialization working even
+	// if go-git cannot parse repository extensions.
+	allowUnsupportedGitExtensions bool
 
 	// envFilesReadOrder is a list of paths to .env files
 	// to read from.
@@ -174,6 +186,12 @@ func normalizeAndValidatePath(path string) (string, error) {
 	return path, nil
 }
 
+func isUnsupportedGitOpenError(err error) bool {
+	return errors.Is(err, git.ErrUnsupportedExtensionRepositoryFormatVersion) ||
+		errors.Is(err, git.ErrUnknownExtension) ||
+		errors.Is(err, git.ErrUnsupportedRepositoryFormatVersion)
+}
+
 func NewDirProject(
 	dir string,
 	opts ...ProjectOption,
@@ -184,6 +202,10 @@ func NewDirProject(
 		opt(p)
 	}
 
+	if p.logger == nil {
+		p.logger = zap.NewNop()
+	}
+
 	var err error
 
 	dir, err = normalizeAndValidatePath(dir)
@@ -204,7 +226,15 @@ func NewDirProject(
 		openOptions,
 	)
 	if err != nil && !errors.Is(err, git.ErrRepositoryNotExists) {
-		return nil, errors.Wrapf(err, "failed to open dir-based project %q", dir)
+		if !p.allowUnsupportedGitExtensions || !isUnsupportedGitOpenError(err) {
+			return nil, errors.Wrapf(err, "failed to open dir-based project %q", dir)
+		}
+
+		p.logger.Info(
+			"failed to open git repository due to unsupported extensions; continuing with directory project",
+			zap.String("dir", dir),
+			zap.Error(err),
+		)
 	}
 
 	if p.repo != nil {
@@ -215,10 +245,6 @@ func NewDirProject(
 		p.fs = wt.Filesystem
 	}
 
-	if p.logger == nil {
-		p.logger = zap.NewNop()
-	}
-
 	return p, nil
 }
 

project/project_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/go-git/go-git/v5"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -76,6 +77,27 @@ func TestNewDirProject(t *testing.T) {
 	})
 }
 
+func TestNewDirProject_FallbackOnUnsupportedGitExtensions(t *testing.T) {
+	repoDir := t.TempDir()
+	_, err := git.PlainInit(repoDir, false)
+	require.NoError(t, err)
+
+	configPath := filepath.Join(repoDir, ".git", "config")
+	f, err := os.OpenFile(configPath, os.O_APPEND|os.O_WRONLY, 0)
+	require.NoError(t, err)
+	_, err = f.WriteString("\n[extensions]\n\tworktreeConfig = true\n")
+	require.NoError(t, err)
+	require.NoError(t, f.Close())
+
+	_, err = NewDirProject(repoDir)
+	require.Error(t, err)
+
+	p, err := NewDirProject(repoDir, WithAllowUnsupportedGitExtensions(true))
+	require.NoError(t, err)
+	require.Nil(t, p.repo)
+	assert.Equal(t, repoDir, p.Root())
+}
+
 func TestNewFileProject(t *testing.T) {
 	temp := t.TempDir()
 	testData := teststub.Setup(t, temp)

project/projectservice/project_service.go

@@ -103,6 +103,8 @@ func projectFromReq(req *projectv1.LoadRequest) (*project.Project, error) {
 			opts = append(opts, project.WithFindRepoUpward())
 		}
 
+		opts = append(opts, project.WithAllowUnsupportedGitExtensions(true))
+
 		return project.NewDirProject(v.Directory.Path, opts...)
 	case *projectv1.LoadRequest_File:
 		return project.NewFileProject(v.File.Path)

runner/service.go

@@ -202,6 +202,8 @@ func ConvertRunnerProject(runnerProj *runnerv1.Project) (*project.Project, error
 		opts = append(opts, project.WithEnvFilesReadOrder(runnerProj.EnvLoadOrder))
 	}
 
+	opts = append(opts, project.WithAllowUnsupportedGitExtensions(true))
+
 	proj, err := project.NewDirProject(runnerProj.Root, opts...)
 	if err != nil {
 		return nil, err

runnerv2service/convert.go

@@ -20,7 +20,7 @@ func convertProtoProjectToProject(runnerProj *runnerv2.Project) (*project.Projec
 		return nil, nil
 	}
 
-	opts := project.DefaultProjectOptions[:]
+	opts := append(project.DefaultProjectOptions[:], project.WithAllowUnsupportedGitExtensions(true))
 
 	if runnerProj.EnvLoadOrder != nil {
 		opts = append(opts, project.WithEnvFilesReadOrder(runnerProj.EnvLoadOrder))