Skip to content

Modern Docker Management, Designed for Everyone

fix: allow remote git build contexts (#1968)

Kyle Mendell5d74bcf2bb4a
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index de2b08174..0ccaca7a6 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -70,7 +70,8 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Config
svcs.Dashboard = services.NewDashboardService(db, svcs.Docker, svcs.Vulnerability)
svcs.ImageUpdate = services.NewImageUpdateService(db, svcs.Settings, svcs.ContainerRegistry, svcs.Docker, svcs.Event, svcs.Notification)
svcs.Image = services.NewImageService(db, svcs.Docker, svcs.ContainerRegistry, svcs.ImageUpdate, svcs.Vulnerability, svcs.Event)
- svcs.Build = services.NewBuildService(db, svcs.Settings, svcs.Docker, svcs.ContainerRegistry)
+ svcs.GitRepository = services.NewGitRepositoryService(db, cfg.GitWorkDir, svcs.Event, svcs.Settings)
+ svcs.Build = services.NewBuildService(db, svcs.Settings, svcs.Docker, svcs.ContainerRegistry, svcs.GitRepository)
svcs.BuildWorkspace = services.NewBuildWorkspaceService(svcs.Settings)
svcs.Project = services.NewProjectService(db, svcs.Settings, svcs.Event, svcs.Image, svcs.Docker, svcs.Build)
svcs.Environment = services.NewEnvironmentService(db, httpClient, svcs.Docker, svcs.Event, svcs.Settings)
@@ -85,7 +86,6 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Config
svcs.Version = services.NewVersionService(httpClient, cfg.UpdateCheckDisabled, config.Version, config.Revision, svcs.ContainerRegistry, svcs.Docker)
svcs.SystemUpgrade = services.NewSystemUpgradeService(svcs.Docker, svcs.Version, svcs.Event, svcs.Settings)
svcs.Updater = services.NewUpdaterService(db, svcs.Settings, svcs.Docker, svcs.Project, svcs.ImageUpdate, svcs.ContainerRegistry, svcs.Event, svcs.Image, svcs.Notification, svcs.SystemUpgrade)
- svcs.GitRepository = services.NewGitRepositoryService(db, cfg.GitWorkDir, svcs.Event, svcs.Settings)
svcs.GitOpsSync = services.NewGitOpsSyncService(db, svcs.GitRepository, svcs.Project, svcs.Event)
return svcs, dockerClient, nil
diff --git a/backend/internal/services/build_service.go b/backend/internal/services/build_service.go
index 26a69c423..aee66bf45 100644
--- a/backend/internal/services/build_service.go
+++ b/backend/internal/services/build_service.go
@@ -2,15 +2,19 @@ package services
import (
"context"
+ "encoding/json"
"errors"
"fmt"
"io"
"log/slog"
+ "os"
+ "path/filepath"
"strings"
"time"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ buildgit "github.com/getarcaneapp/arcane/backend/internal/utils/git"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
libbuild "github.com/getarcaneapp/arcane/backend/pkg/libarcane/libbuild"
buildtypes "github.com/getarcaneapp/arcane/types/builds"
@@ -24,17 +28,27 @@ type BuildService struct {
settings *SettingsService
dockerService *DockerClientService
registryService *ContainerRegistryService
+ gitRepository *GitRepositoryService
builder buildtypes.Builder
+ gitCloneFn func(context.Context, string, string, buildgit.AuthConfig) (string, error)
+ gitCleanupFn func(string) error
}
const buildHistoryOutputLimitBytes = 2 * 1024 * 1024
-func NewBuildService(db *database.DB, settings *SettingsService, dockerService *DockerClientService, registryService *ContainerRegistryService) *BuildService {
+func NewBuildService(
+ db *database.DB,
+ settings *SettingsService,
+ dockerService *DockerClientService,
+ registryService *ContainerRegistryService,
+ gitRepository *GitRepositoryService,
+) *BuildService {
svc := &BuildService{
db: db,
settings: settings,
dockerService: dockerService,
registryService: registryService,
+ gitRepository: gitRepository,
}
svc.builder = libbuild.NewBuilder(svc, dockerService, svc)
@@ -96,10 +110,26 @@ func (s *BuildService) BuildImage(ctx context.Context, environmentID string, req
}
startedAt := time.Now()
- result, err := s.builder.BuildImage(ctx, req, writer, serviceName)
+ cleanupResolvedContext := func() error { return nil }
+ var (
+ result *imagetypes.BuildResult
+ err error
+ )
+
+ if resolvedReq, cleanupFn, resolveErr := s.resolveBuildRequestInternal(ctx, req, writer, serviceName); resolveErr != nil {
+ err = resolveErr
+ } else {
+ cleanupResolvedContext = cleanupFn
+ result, err = s.builder.BuildImage(ctx, resolvedReq, writer, serviceName)
+ }
+
completedAt := time.Now()
durationMs := completedAt.Sub(startedAt).Milliseconds()
+ if cleanupErr := cleanupResolvedContext(); cleanupErr != nil {
+ slog.WarnContext(ctx, "failed to cleanup temporary git build context", "error", cleanupErr)
+ }
+
if s.db != nil && buildRecordID != "" {
output := logCapture.String()
var outputPtr *string
@@ -134,6 +164,125 @@ func (s *BuildService) BuildImage(ctx context.Context, environmentID string, req
return result, err
}
+func (s *BuildService) resolveBuildRequestInternal(
+ ctx context.Context,
+ req imagetypes.BuildRequest,
+ progressWriter io.Writer,
+ serviceName string,
+) (imagetypes.BuildRequest, func() error, error) {
+ source, ok, err := libbuild.ParseGitBuildContextSource(req.ContextDir)
+ if err != nil {
+ return imagetypes.BuildRequest{}, func() error { return nil }, err
+ }
+ if !ok || source == nil {
+ if libbuild.IsPotentialRemoteBuildContextSource(req.ContextDir) {
+ return imagetypes.BuildRequest{}, func() error { return nil }, fmt.Errorf("unsupported remote build context source %q: only git repository URLs are supported", req.ContextDir)
+ }
+ return req, func() error { return nil }, nil
+ }
+
+ writeBuildProgressStatusInternal(progressWriter, serviceName, fmt.Sprintf("resolving remote git context %s", source.RepositoryURL))
+
+ authConfig, matchedRepository, err := s.resolveGitBuildAuthInternal(ctx, source.RepositoryURL)
+ if err != nil {
+ return imagetypes.BuildRequest{}, func() error { return nil }, err
+ }
+ if matchedRepository {
+ writeBuildProgressStatusInternal(progressWriter, serviceName, fmt.Sprintf("using saved git credentials for %s", source.RepositoryURL))
+ }
+
+ repoPath, err := s.cloneGitContextInternal(ctx, source.RepositoryURL, source.Ref, authConfig)
+ if err != nil {
+ return imagetypes.BuildRequest{}, func() error { return nil }, err
+ }
+
+ contextDir := repoPath
+ if source.Subdir != "" {
+ if err := buildgit.ValidatePath(repoPath, filepath.FromSlash(source.Subdir)); err != nil {
+ _ = s.cleanupGitContextInternal(repoPath)
+ return imagetypes.BuildRequest{}, func() error { return nil }, fmt.Errorf("invalid git build context subdir: %w", err)
+ }
+ contextDir = filepath.Join(repoPath, filepath.FromSlash(source.Subdir))
+ }
+
+ info, err := os.Stat(contextDir)
+ if err != nil {
+ _ = s.cleanupGitContextInternal(repoPath)
+ return imagetypes.BuildRequest{}, func() error { return nil }, fmt.Errorf("failed to stat resolved git build context: %w", err)
+ }
+ if !info.IsDir() {
+ _ = s.cleanupGitContextInternal(repoPath)
+ return imagetypes.BuildRequest{}, func() error { return nil }, fmt.Errorf("resolved git build context is not a directory")
+ }
+
+ writeBuildProgressStatusInternal(progressWriter, serviceName, fmt.Sprintf("using remote build context %s", source.Raw))
+
+ resolvedReq := req
+ resolvedReq.ContextDir = contextDir
+
+ return resolvedReq, func() error { return s.cleanupGitContextInternal(repoPath) }, nil
+}
+
+func (s *BuildService) resolveGitBuildAuthInternal(ctx context.Context, rawURL string) (buildgit.AuthConfig, bool, error) {
+ if s.gitRepository == nil {
+ return buildgit.AuthConfig{}, false, nil
+ }
+
+ repository, err := s.gitRepository.FindEnabledRepositoryByURL(ctx, rawURL)
+ if err != nil {
+ return buildgit.AuthConfig{}, false, fmt.Errorf("failed to resolve git repository credentials: %w", err)
+ }
+ if repository == nil {
+ return buildgit.AuthConfig{}, false, nil
+ }
+
+ authConfig, err := s.gitRepository.GetAuthConfig(ctx, repository)
+ if err != nil {
+ return buildgit.AuthConfig{}, true, fmt.Errorf("failed to load git repository credentials: %w", err)
+ }
+
+ return authConfig, true, nil
+}
+
+func (s *BuildService) cloneGitContextInternal(ctx context.Context, repositoryURL, ref string, authConfig buildgit.AuthConfig) (string, error) {
+ if s.gitCloneFn != nil {
+ return s.gitCloneFn(ctx, repositoryURL, ref, authConfig)
+ }
+
+ if s.gitRepository != nil && s.gitRepository.gitClient != nil {
+ return s.gitRepository.gitClient.Clone(ctx, repositoryURL, ref, authConfig)
+ }
+
+ return buildgit.NewClient("").Clone(ctx, repositoryURL, ref, authConfig)
+}
+
+func (s *BuildService) cleanupGitContextInternal(repoPath string) error {
+ if repoPath == "" {
+ return nil
+ }
+ if s.gitCleanupFn != nil {
+ return s.gitCleanupFn(repoPath)
+ }
+ if s.gitRepository != nil && s.gitRepository.gitClient != nil {
+ return s.gitRepository.gitClient.Cleanup(repoPath)
+ }
+ return buildgit.NewClient("").Cleanup(repoPath)
+}
+
+func writeBuildProgressStatusInternal(progressWriter io.Writer, serviceName, status string) {
+ if progressWriter == nil || strings.TrimSpace(status) == "" {
+ return
+ }
+
+ if err := json.NewEncoder(progressWriter).Encode(imagetypes.ProgressEvent{
+ Type: "build",
+ Service: serviceName,
+ Status: status,
+ }); err != nil {
+ slog.Debug("failed to write build progress status", "error", err)
+ }
+}
+
func (s *BuildService) ListImageBuildsByEnvironmentPaginated(ctx context.Context, environmentID string, params pagination.QueryParams) ([]imagetypes.BuildRecord, pagination.Response, error) {
if s.db == nil {
return nil, pagination.Response{}, fmt.Errorf("build history not available")
diff --git a/backend/internal/services/build_service_test.go b/backend/internal/services/build_service_test.go
index 8d78e7110..bd8ba2b87 100644
--- a/backend/internal/services/build_service_test.go
+++ b/backend/internal/services/build_service_test.go
@@ -2,10 +2,20 @@ package services
import (
"context"
+ "io"
+ "os"
+ "path/filepath"
"testing"
+ "github.com/getarcaneapp/arcane/backend/internal/database"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"
+ buildgit "github.com/getarcaneapp/arcane/backend/internal/utils/git"
+ "github.com/getarcaneapp/arcane/types/image"
+ glsqlite "github.com/glebarez/sqlite"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "gorm.io/gorm"
)
func TestBuildService_GetRegistryAuthForHost_UsesDatabaseCredentials(t *testing.T) {
@@ -66,3 +76,208 @@ func TestBuildService_GetAllRegistryAuthConfigs_NoRegistryService(t *testing.T)
require.NoError(t, err)
assert.Nil(t, authConfigs)
}
+
+func TestBuildService_ResolveBuildRequest_PassesThroughLocalContext(t *testing.T) {
+ contextDir := t.TempDir()
+ svc := &BuildService{
+ gitCloneFn: func(context.Context, string, string, buildgit.AuthConfig) (string, error) {
+ t.Fatal("git clone should not run for local contexts")
+ return "", nil
+ },
+ }
+
+ req := image.BuildRequest{
+ ContextDir: contextDir,
+ Dockerfile: "Dockerfile",
+ }
+
+ resolvedReq, cleanup, err := svc.resolveBuildRequestInternal(context.Background(), req, nil, "")
+ require.NoError(t, err)
+ require.NotNil(t, cleanup)
+ assert.Equal(t, req, resolvedReq)
+ require.NoError(t, cleanup())
+}
+
+func TestBuildService_ResolveBuildRequest_ClonesRemoteGitContext(t *testing.T) {
+ repoPath := t.TempDir()
+ require.NoError(t, os.MkdirAll(filepath.Join(repoPath, "docker", "app"), 0o755))
+
+ cleanupCalled := false
+ svc := &BuildService{
+ gitCloneFn: func(_ context.Context, repositoryURL, ref string, auth buildgit.AuthConfig) (string, error) {
+ assert.Equal(t, "https://github.com/getarcaneapp/arcane.git", repositoryURL)
+ assert.Equal(t, "main", ref)
+ assert.Equal(t, buildgit.AuthConfig{}, auth)
+ return repoPath, nil
+ },
+ gitCleanupFn: func(path string) error {
+ cleanupCalled = true
+ assert.Equal(t, repoPath, path)
+ return nil
+ },
+ }
+
+ req := image.BuildRequest{
+ ContextDir: "https://github.com/getarcaneapp/arcane.git#main:docker/app",
+ Dockerfile: "Dockerfile",
+ }
+
+ resolvedReq, cleanup, err := svc.resolveBuildRequestInternal(context.Background(), req, nil, "manual")
+ require.NoError(t, err)
+ assert.Equal(t, filepath.Join(repoPath, "docker", "app"), resolvedReq.ContextDir)
+ require.NoError(t, cleanup())
+ assert.True(t, cleanupCalled)
+}
+
+func TestBuildService_ResolveBuildRequest_RejectsUnsupportedRemoteContext(t *testing.T) {
+ svc := &BuildService{}
+
+ _, cleanup, err := svc.resolveBuildRequestInternal(
+ context.Background(),
+ image.BuildRequest{ContextDir: "https://example.com/archive.tar.gz"},
+ nil,
+ "",
+ )
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "only git repository URLs are supported")
+ require.NoError(t, cleanup())
+}
+
+func TestBuildService_ResolveBuildRequest_UsesSavedGitCredentials(t *testing.T) {
+ _, db := setupImageServiceAuthTest(t)
+ require.NoError(t, db.AutoMigrate(&models.GitRepository{}))
+
+ repoService := NewGitRepositoryService(db, t.TempDir(), nil, nil)
+ createTestGitRepository(t, db, models.GitRepository{
+ Name: "private-http",
+ URL: "https://github.com/getarcaneapp/private-build.git",
+ AuthType: "http",
+ Username: "builder",
+ Token: encryptSecretForTest(t, "token-123"),
+ SSHHostKeyVerification: "accept_new",
+ Enabled: true,
+ })
+ createTestGitRepository(t, db, models.GitRepository{
+ Name: "private-ssh",
+ URL: "[email protected]:getarcaneapp/private-ssh.git",
+ AuthType: "ssh",
+ SSHKey: encryptSecretForTest(t, "ssh-private-key"),
+ SSHHostKeyVerification: "strict",
+ Enabled: true,
+ })
+
+ t.Run("http auth", func(t *testing.T) {
+ svc := &BuildService{
+ gitRepository: repoService,
+ gitCloneFn: func(_ context.Context, _ string, _ string, auth buildgit.AuthConfig) (string, error) {
+ assert.Equal(t, "http", auth.AuthType)
+ assert.Equal(t, "builder", auth.Username)
+ assert.Equal(t, "token-123", auth.Token)
+ return t.TempDir(), nil
+ },
+ gitCleanupFn: func(string) error { return nil },
+ }
+
+ _, cleanup, err := svc.resolveBuildRequestInternal(
+ context.Background(),
+ image.BuildRequest{ContextDir: "https://github.com/getarcaneapp/private-build.git#main"},
+ nil,
+ "",
+ )
+ require.NoError(t, err)
+ require.NoError(t, cleanup())
+ })
+
+ t.Run("ssh auth", func(t *testing.T) {
+ svc := &BuildService{
+ gitRepository: repoService,
+ gitCloneFn: func(_ context.Context, _ string, _ string, auth buildgit.AuthConfig) (string, error) {
+ assert.Equal(t, "ssh", auth.AuthType)
+ assert.Equal(t, "ssh-private-key", auth.SSHKey)
+ assert.Equal(t, "strict", auth.SSHHostKeyVerification)
+ return t.TempDir(), nil
+ },
+ gitCleanupFn: func(string) error { return nil },
+ }
+
+ _, cleanup, err := svc.resolveBuildRequestInternal(
+ context.Background(),
+ image.BuildRequest{ContextDir: "[email protected]:getarcaneapp/private-ssh.git#main"},
+ nil,
+ "",
+ )
+ require.NoError(t, err)
+ require.NoError(t, cleanup())
+ })
+}
+
+func TestBuildService_BuildImage_PreservesRemoteSourceInHistory(t *testing.T) {
+ db, err := setupBuildHistoryTestDB()
+ require.NoError(t, err)
+
+ repoPath := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(repoPath, "Dockerfile"), []byte("FROM alpine:3.20\n"), 0o644))
+
+ captured := image.BuildRequest{}
+ svc := &BuildService{
+ db: db,
+ builder: testBuildRecorder{
+ onBuild: func(req image.BuildRequest) {
+ captured = req
+ },
+ },
+ gitCloneFn: func(_ context.Context, _ string, _ string, _ buildgit.AuthConfig) (string, error) {
+ return repoPath, nil
+ },
+ gitCleanupFn: func(string) error { return nil },
+ }
+
+ req := image.BuildRequest{
+ ContextDir: "https://github.com/getarcaneapp/arcane.git#main",
+ Dockerfile: "Dockerfile",
+ Tags: []string{"ghcr.io/getarcaneapp/arcane:test"},
+ Load: true,
+ }
+
+ _, err = svc.BuildImage(context.Background(), "0", req, nil, "manual", nil)
+ require.NoError(t, err)
+ assert.Equal(t, repoPath, captured.ContextDir)
+
+ var record models.ImageBuild
+ require.NoError(t, db.WithContext(context.Background()).First(&record).Error)
+ assert.Equal(t, req.ContextDir, record.ContextDir)
+}
+
+type testBuildRecorder struct {
+ onBuild func(image.BuildRequest)
+}
+
+func (b testBuildRecorder) BuildImage(_ context.Context, req image.BuildRequest, _ io.Writer, _ string) (*image.BuildResult, error) {
+ if b.onBuild != nil {
+ b.onBuild(req)
+ }
+ return &image.BuildResult{Provider: "local"}, nil
+}
+
+func setupBuildHistoryTestDB() (*database.DB, error) {
+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ if err != nil {
+ return nil, err
+ }
+ if err := db.AutoMigrate(&models.ImageBuild{}); err != nil {
+ return nil, err
+ }
+ return &database.DB{DB: db}, nil
+}
+
+func createTestGitRepository(t *testing.T, db *database.DB, repository models.GitRepository) {
+ t.Helper()
+ require.NoError(t, db.WithContext(context.Background()).Create(&repository).Error)
+}
+
+func encryptSecretForTest(t *testing.T, value string) string {
+ t.Helper()
+ encrypted, err := crypto.Encrypt(value)
+ require.NoError(t, err)
+ return encrypted
+}
diff --git a/backend/internal/services/git_repository_service.go b/backend/internal/services/git_repository_service.go
index 858713b30..9386687a0 100644
--- a/backend/internal/services/git_repository_service.go
+++ b/backend/internal/services/git_repository_service.go
@@ -14,6 +14,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/utils/mapper"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
+ libbuild "github.com/getarcaneapp/arcane/backend/pkg/libarcane/libbuild"
"github.com/getarcaneapp/arcane/types/gitops"
"gorm.io/gorm"
)
@@ -84,6 +85,41 @@ func (s *GitRepositoryService) GetRepositoryByName(ctx context.Context, name str
return &repository, nil
}
+func (s *GitRepositoryService) FindEnabledRepositoryByURL(ctx context.Context, rawURL string) (*models.GitRepository, error) {
+ if s == nil || s.db == nil {
+ return nil, nil
+ }
+
+ normalizedURL := libbuild.NormalizeGitBuildContextSourceForMatch(rawURL)
+ if normalizedURL == "" {
+ return nil, nil
+ }
+
+ likePrefix := normalizedURL
+ if idx := strings.Index(likePrefix, "#"); idx >= 0 {
+ likePrefix = likePrefix[:idx]
+ }
+ likePrefix = strings.TrimSuffix(likePrefix, "/")
+
+ var repositories []models.GitRepository
+ query := s.db.WithContext(ctx).Where("enabled = ?", true)
+ if likePrefix != "" {
+ query = query.Where("url = ? OR url = ? OR url LIKE ? OR url LIKE ?", rawURL, normalizedURL, likePrefix+"%", likePrefix+"/%")
+ }
+ if err := query.Find(&repositories).Error; err != nil {
+ return nil, fmt.Errorf("failed to list repositories: %w", err)
+ }
+
+ for i := range repositories {
+ if libbuild.NormalizeGitBuildContextSourceForMatch(repositories[i].URL) == normalizedURL {
+ repository := repositories[i]
+ return &repository, nil
+ }
+ }
+
+ return nil, nil
+}
+
func (s *GitRepositoryService) CreateRepository(ctx context.Context, req models.CreateGitRepositoryRequest, actor models.User) (*models.GitRepository, error) {
repository := models.GitRepository{
Name: req.Name,
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 7a459381c..94f348e4a 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -26,6 +26,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/backend/internal/utils/pathmapper"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
+ libbuild "github.com/getarcaneapp/arcane/backend/pkg/libarcane/libbuild"
"github.com/getarcaneapp/arcane/backend/pkg/projects"
"github.com/getarcaneapp/arcane/types"
"github.com/getarcaneapp/arcane/types/containerregistry"
@@ -1451,7 +1452,11 @@ func resolveBuildContextInternal(workingDir string, svc composetypes.ServiceConf
contextDir := strings.TrimSpace(svc.Build.Context)
if contextDir == "" {
contextDir = workingDir
- } else if !filepath.IsAbs(contextDir) {
+ } else if _, isGitContext, err := libbuild.ParseGitBuildContextSource(contextDir); err != nil {
+ return "", fmt.Errorf("invalid build context for service %s: %w", serviceName, err)
+ } else if libbuild.IsPotentialRemoteBuildContextSource(contextDir) && !isGitContext {
+ return "", fmt.Errorf("unsupported remote build context for service %s: only git repository URLs are supported", serviceName)
+ } else if !isGitContext && !filepath.IsAbs(contextDir) {
contextDir = filepath.Join(workingDir, contextDir)
}
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 391b0e75b..e571cf9be 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -942,6 +942,30 @@ func TestProjectService_DeployProject_BuildsGeneratedImageWithoutPull(t *testing
assert.NotContains(t, err.Error(), "failed to resolve reference \"arcane.local/")
}
+func TestResolveBuildContextInternal_AllowsRemoteGitContext(t *testing.T) {
+ svc := composetypes.ServiceConfig{
+ Build: &composetypes.BuildConfig{
+ Context: "https://github.com/getarcaneapp/arcane.git#main:docker/app",
+ },
+ }
+
+ contextDir, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ require.NoError(t, err)
+ assert.Equal(t, "https://github.com/getarcaneapp/arcane.git#main:docker/app", contextDir)
+}
+
+func TestResolveBuildContextInternal_RejectsUnsupportedRemoteContext(t *testing.T) {
+ svc := composetypes.ServiceConfig{
+ Build: &composetypes.BuildConfig{
+ Context: "https://example.com/archive.tar.gz",
+ },
+ }
+
+ _, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "only git repository URLs are supported")
+}
+
//go:fix inline
func ptr(v string) *string {
return new(v)
diff --git a/backend/pkg/libarcane/libbuild/build_context.go b/backend/pkg/libarcane/libbuild/build_context.go
new file mode 100644
index 000000000..e7072441d
--- /dev/null
+++ b/backend/pkg/libarcane/libbuild/build_context.go
@@ -0,0 +1,125 @@
+package libbuild
+
+import (
+ "fmt"
+ "net/url"
+ "path"
+ "strings"
+)
+
+type GitBuildContextSource struct {
+ Raw string
+ RepositoryURL string
+ Ref string
+ Subdir string
+}
+
+func ParseGitBuildContextSource(raw string) (*GitBuildContextSource, bool, error) {
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return nil, false, nil
+ }
+
+ repositoryURL, fragment, hasFragment := strings.Cut(trimmed, "#")
+ repositoryURL = strings.TrimSpace(repositoryURL)
+ if !IsSupportedGitRepositoryURL(repositoryURL) {
+ return nil, false, nil
+ }
+
+ source := &GitBuildContextSource{
+ Raw: trimmed,
+ RepositoryURL: strings.TrimRight(repositoryURL, "/"),
+ }
+
+ if !hasFragment {
+ return source, true, nil
+ }
+
+ fragment = strings.TrimSpace(fragment)
+ if fragment == "" {
+ return nil, true, fmt.Errorf("git build context fragment cannot be empty")
+ }
+
+ ref, subdir, hasSubdir := strings.Cut(fragment, ":")
+ ref = strings.TrimSpace(ref)
+ if ref == "" {
+ return nil, true, fmt.Errorf("git build context ref cannot be empty")
+ }
+ source.Ref = ref
+
+ if !hasSubdir {
+ return source, true, nil
+ }
+
+ subdir = strings.TrimSpace(subdir)
+ if subdir == "" {
+ return nil, true, fmt.Errorf("git build context subdir cannot be empty")
+ }
+ if strings.HasPrefix(subdir, "/") {
+ return nil, true, fmt.Errorf("git build context subdir must be relative")
+ }
+
+ cleanSubdir := path.Clean(subdir)
+ if cleanSubdir == "." || cleanSubdir == ".." || strings.HasPrefix(cleanSubdir, "../") {
+ return nil, true, fmt.Errorf("git build context subdir must stay within the repository")
+ }
+
+ source.Subdir = cleanSubdir
+ return source, true, nil
+}
+
+func NormalizeGitBuildContextSourceForMatch(raw string) string {
+ source, ok, err := ParseGitBuildContextSource(raw)
+ if err != nil || !ok || source == nil {
+ return ""
+ }
+ return strings.TrimRight(strings.TrimSpace(source.RepositoryURL), "/")
+}
+
+func IsPotentialRemoteBuildContextSource(raw string) bool {
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return false
+ }
+
+ if strings.HasPrefix(trimmed, "git@") {
+ return true
+ }
+
+ parsed, err := url.Parse(trimmed)
+ if err != nil {
+ return false
+ }
+
+ switch strings.ToLower(parsed.Scheme) {
+ case "http", "https", "ssh", "git":
+ return parsed.Host != ""
+ default:
+ return false
+ }
+}
+
+func IsSupportedGitRepositoryURL(raw string) bool {
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return false
+ }
+
+ if strings.HasPrefix(trimmed, "git@") {
+ return true
+ }
+
+ parsed, err := url.Parse(trimmed)
+ if err != nil {
+ return false
+ }
+
+ switch strings.ToLower(parsed.Scheme) {
+ case "git", "ssh":
+ return true
+ case "http", "https":
+ return strings.HasSuffix(strings.ToLower(parsed.Path), ".git")
+ default:
+ return false
+ }
+}
diff --git a/backend/pkg/libarcane/libbuild/build_context_test.go b/backend/pkg/libarcane/libbuild/build_context_test.go
new file mode 100644
index 000000000..201a86ec2
--- /dev/null
+++ b/backend/pkg/libarcane/libbuild/build_context_test.go
@@ -0,0 +1,52 @@
+package libbuild
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestParseGitBuildContextSource(t *testing.T) {
+ t.Run("plain repository url", func(t *testing.T) {
+ source, ok, err := ParseGitBuildContextSource("https://github.com/getarcaneapp/arcane.git")
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.NotNil(t, source)
+ assert.Equal(t, "https://github.com/getarcaneapp/arcane.git", source.RepositoryURL)
+ assert.Empty(t, source.Ref)
+ assert.Empty(t, source.Subdir)
+ })
+
+ t.Run("ref and subdir", func(t *testing.T) {
+ source, ok, err := ParseGitBuildContextSource("https://github.com/getarcaneapp/arcane.git#main:docker/app")
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.NotNil(t, source)
+ assert.Equal(t, "main", source.Ref)
+ assert.Equal(t, "docker/app", source.Subdir)
+ })
+
+ t.Run("ssh url", func(t *testing.T) {
+ source, ok, err := ParseGitBuildContextSource("[email protected]:getarcaneapp/arcane.git#dev")
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.NotNil(t, source)
+ assert.Equal(t, "[email protected]:getarcaneapp/arcane.git", source.RepositoryURL)
+ assert.Equal(t, "dev", source.Ref)
+ })
+
+ t.Run("non git url is ignored", func(t *testing.T) {
+ source, ok, err := ParseGitBuildContextSource("https://example.com/archive.tar.gz")
+ require.NoError(t, err)
+ assert.False(t, ok)
+ assert.Nil(t, source)
+ })
+
+ t.Run("invalid subdir traversal is rejected", func(t *testing.T) {
+ source, ok, err := ParseGitBuildContextSource("https://github.com/getarcaneapp/arcane.git#main:../secrets")
+ require.Error(t, err)
+ assert.True(t, ok)
+ assert.Nil(t, source)
+ })
+}
diff --git a/backend/pkg/libarcane/libbuild/builder_buildkit_local.go b/backend/pkg/libarcane/libbuild/builder_buildkit_local.go
new file mode 100644
index 000000000..8c96e340b
--- /dev/null
+++ b/backend/pkg/libarcane/libbuild/builder_buildkit_local.go
@@ -0,0 +1,102 @@
+package libbuild
+
+import (
+ "bufio"
+ "context"
+ "fmt"
+ "os"
+ "strings"
+ "time"
+
+ dockerbuildkit "github.com/docker/docker/client/buildkit"
+ imagetypes "github.com/getarcaneapp/arcane/types/image"
+ buildkitclient "github.com/moby/buildkit/client"
+)
+
+func (b *builder) newLocalBuildkitSessionInternal(ctx context.Context) (*buildSession, error) {
+ if b.dockerClientProvider == nil {
+ return nil, fmt.Errorf("docker service not available")
+ }
+
+ dockerClient, err := b.dockerClientProvider.GetClient(ctx)
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ bk, err := buildkitclient.New(ctx, "", dockerbuildkit.ClientOpts(dockerClient)...)
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker BuildKit: %w", err)
+ }
+
+ waitCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+ defer cancel()
+ if err := bk.Wait(waitCtx); err != nil {
+ _ = bk.Close()
+ return nil, fmt.Errorf("failed to wait for Docker BuildKit: %w", err)
+ }
+
+ return &buildSession{
+ Client: bk,
+ Close: func(_ error) error {
+ return bk.Close()
+ },
+ }, nil
+}
+
+func requiresLocalBuildkitInternal(req imagetypes.BuildRequest) (bool, error) {
+ fsInput, err := prepareBuildFilesystemInputInternal(req)
+ if err != nil {
+ return false, err
+ }
+
+ contents, err := readDockerfileContentsInternal(fsInput)
+ if err != nil {
+ return false, err
+ }
+
+ return dockerfileRequiresBuildkitInternal(contents), nil
+}
+
+func readDockerfileContentsInternal(input buildFilesystemInput) (string, error) {
+ if input.dockerfileInline != "" {
+ return input.dockerfileInline, nil
+ }
+
+ raw, err := os.ReadFile(input.fullDockerfilePath)
+ if err != nil {
+ return "", fmt.Errorf("failed to read Dockerfile: %w", err)
+ }
+
+ return string(raw), nil
+}
+
+func dockerfileRequiresBuildkitInternal(contents string) bool {
+ scanner := bufio.NewScanner(strings.NewReader(contents))
+ for scanner.Scan() {
+ line := strings.TrimSpace(scanner.Text())
+ if line == "" {
+ continue
+ }
+
+ lower := strings.ToLower(line)
+ if strings.HasPrefix(lower, "# syntax=") {
+ return true
+ }
+
+ if strings.HasPrefix(lower, "#") {
+ continue
+ }
+
+ if strings.HasPrefix(lower, "run ") {
+ if strings.Contains(lower, "--mount=") || strings.Contains(lower, "--network=") || strings.Contains(lower, "--security=") {
+ return true
+ }
+ }
+
+ if (strings.HasPrefix(lower, "copy ") || strings.HasPrefix(lower, "add ")) && strings.Contains(lower, "--link") {
+ return true
+ }
+ }
+
+ return false
+}
diff --git a/backend/pkg/libarcane/libbuild/builder_buildkit_local_test.go b/backend/pkg/libarcane/libbuild/builder_buildkit_local_test.go
new file mode 100644
index 000000000..7a32dfb0d
--- /dev/null
+++ b/backend/pkg/libarcane/libbuild/builder_buildkit_local_test.go
@@ -0,0 +1,46 @@
+package libbuild
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+
+ imagetypes "github.com/getarcaneapp/arcane/types/image"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDockerfileRequiresBuildkitInternal(t *testing.T) {
+ t.Run("syntax directive enables buildkit", func(t *testing.T) {
+ assert.True(t, dockerfileRequiresBuildkitInternal("# syntax=docker/dockerfile:1.7\nFROM alpine:3.20\n"))
+ })
+
+ t.Run("run mount enables buildkit", func(t *testing.T) {
+ assert.True(t, dockerfileRequiresBuildkitInternal("FROM oven/bun:alpine\nRUN --mount=type=cache,target=/root/.bun bun install\n"))
+ })
+
+ t.Run("plain dockerfile stays on classic docker", func(t *testing.T) {
+ assert.False(t, dockerfileRequiresBuildkitInternal("FROM alpine:3.20\nRUN echo hello\n"))
+ })
+}
+
+func TestRequiresLocalBuildkitInternal_ReadsRequestedDockerfile(t *testing.T) {
+ contextDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(contextDir, "Dockerfile.custom"), []byte("FROM alpine:3.20\nRUN --mount=type=cache,target=/tmp/cache echo hi\n"), 0o644))
+
+ required, err := requiresLocalBuildkitInternal(imagetypes.BuildRequest{
+ ContextDir: contextDir,
+ Dockerfile: "Dockerfile.custom",
+ })
+ require.NoError(t, err)
+ assert.True(t, required)
+}
+
+func TestRequiresLocalBuildkitInternal_UsesInlineDockerfile(t *testing.T) {
+ required, err := requiresLocalBuildkitInternal(imagetypes.BuildRequest{
+ ContextDir: t.TempDir(),
+ DockerfileInline: "FROM alpine:3.20\nRUN --mount=type=cache,target=/tmp/cache echo hi\n",
+ })
+ require.NoError(t, err)
+ assert.True(t, required)
+}
diff --git a/backend/pkg/libarcane/libbuild/builder_core.go b/backend/pkg/libarcane/libbuild/builder_core.go
index 89b7fb8c5..06206d75f 100644
--- a/backend/pkg/libarcane/libbuild/builder_core.go
+++ b/backend/pkg/libarcane/libbuild/builder_core.go
@@ -65,6 +65,17 @@ func (b *builder) BuildImage(ctx context.Context, req imagetypes.BuildRequest, p
}
if providerName == "local" {
+ requiresBuildkit, err := requiresLocalBuildkitInternal(req)
+ if err != nil {
+ return nil, err
+ }
+ if requiresBuildkit {
+ session, err := b.newLocalBuildkitSessionInternal(buildCtx)
+ if err != nil {
+ return nil, err
+ }
+ return b.buildWithBuildkitSessionInternal(buildCtx, req, progressWriter, serviceName, providerName, session)
+ }
return b.buildWithDockerInternal(buildCtx, req, progressWriter, serviceName)
}
@@ -77,6 +88,21 @@ func (b *builder) BuildImage(ctx context.Context, req imagetypes.BuildRequest, p
return nil, err
}
+ return b.buildWithBuildkitSessionInternal(buildCtx, req, progressWriter, serviceName, providerName, session)
+}
+
+func (b *builder) buildWithBuildkitSessionInternal(
+ ctx context.Context,
+ req imagetypes.BuildRequest,
+ progressWriter io.Writer,
+ serviceName string,
+ providerName string,
+ session *buildSession,
+) (*imagetypes.BuildResult, error) {
+ if session == nil || session.Client == nil {
+ return nil, errors.New("build session not available")
+ }
+
var buildErr error
defer func() {
if cerr := session.Close(buildErr); cerr != nil {
@@ -84,7 +110,7 @@ func (b *builder) BuildImage(ctx context.Context, req imagetypes.BuildRequest, p
}
}()
- solveOpt, loadErrCh, cleanupSolveOpt, err := b.buildSolveOptInternal(buildCtx, req)
+ solveOpt, loadErrCh, cleanupSolveOpt, err := b.buildSolveOptInternal(ctx, req)
if err != nil {
buildErr = err
return nil, err
@@ -99,7 +125,7 @@ func (b *builder) BuildImage(ctx context.Context, req imagetypes.BuildRequest, p
statusCh := make(chan *buildkit.SolveStatus, 16)
streamErrCh := make(chan error, 1)
go func() {
- streamErrCh <- streamSolveStatusInternal(buildCtx, statusCh, progressWriter, serviceName)
+ streamErrCh <- streamSolveStatusInternal(ctx, statusCh, progressWriter, serviceName)
}()
writeProgressEventInternal(progressWriter, imagetypes.ProgressEvent{
@@ -109,7 +135,7 @@ func (b *builder) BuildImage(ctx context.Context, req imagetypes.BuildRequest, p
Status: "build started",
})
- resp, err := session.Client.Solve(buildCtx, nil, solveOpt, statusCh)
+ resp, err := session.Client.Solve(ctx, nil, solveOpt, statusCh)
buildErr = err
if err != nil {
diff --git a/backend/pkg/libarcane/libbuild/builder_docker.go b/backend/pkg/libarcane/libbuild/builder_docker.go
index 5c63e2919..7edee9e72 100644
--- a/backend/pkg/libarcane/libbuild/builder_docker.go
+++ b/backend/pkg/libarcane/libbuild/builder_docker.go
@@ -19,6 +19,7 @@ import (
"github.com/moby/moby/api/types/jsonstream"
dockerregistry "github.com/moby/moby/api/types/registry"
dockerclient "github.com/moby/moby/client"
+ "github.com/moby/patternmatcher"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
)
@@ -111,6 +112,13 @@ func prepareBuildFilesystemInputInternal(req imagetypes.BuildRequest) (buildFile
relDockerfile, relErr := filepath.Rel(contextDir, fullDockerfilePath)
dockerfileOutsideCtx := relErr != nil || strings.HasPrefix(relDockerfile, "..")
+ if !dockerfileOutsideCtx {
+ excluded, err := dockerfileExcludedByDockerignoreInternal(contextDir, relDockerfile)
+ if err != nil {
+ return buildFilesystemInput{}, err
+ }
+ dockerfileOutsideCtx = excluded
+ }
if dockerfileOutsideCtx {
relDockerfile = filepath.Base(fullDockerfilePath)
} else {
@@ -581,3 +589,27 @@ func readDockerignoreInternal(contextDir string) []string {
return patterns
}
+
+func dockerfileExcludedByDockerignoreInternal(contextDir, dockerfilePath string) (bool, error) {
+ patterns := readDockerignoreInternal(contextDir)
+ if len(patterns) == 0 {
+ return false, nil
+ }
+
+ matcher, err := patternmatcher.New(patterns)
+ if err != nil {
+ return false, fmt.Errorf("invalid .dockerignore: %w", err)
+ }
+
+ relDockerfile := filepath.ToSlash(filepath.Clean(dockerfilePath))
+ if relDockerfile == "." || relDockerfile == "" {
+ return false, nil
+ }
+
+ excluded, err := matcher.MatchesOrParentMatches(relDockerfile)
+ if err != nil {
+ return false, fmt.Errorf("failed to evaluate .dockerignore for Dockerfile: %w", err)
+ }
+
+ return excluded, nil
+}
diff --git a/backend/pkg/libarcane/libbuild/builder_docker_test.go b/backend/pkg/libarcane/libbuild/builder_docker_test.go
index b1158bfef..857f35919 100644
--- a/backend/pkg/libarcane/libbuild/builder_docker_test.go
+++ b/backend/pkg/libarcane/libbuild/builder_docker_test.go
@@ -48,6 +48,7 @@ func TestBuildDockerImageOptionsInternal_IncludesAuthConfigs(t *testing.T) {
require.NoError(t, err)
require.NotNil(t, buildOpts.AuthConfigs)
assert.Equal(t, authConfigs, buildOpts.AuthConfigs)
+ assert.Empty(t, buildOpts.Version)
require.Len(t, buildOpts.Platforms, 1)
assert.Equal(t, "linux", buildOpts.Platforms[0].OS)
assert.Equal(t, "amd64", buildOpts.Platforms[0].Architecture)
@@ -93,3 +94,34 @@ func TestPrepareDockerBuildContextInternal_StagesInlineDockerfile(t *testing.T)
require.NoError(t, err)
assert.Equal(t, "hello\n", string(appContents))
}
+
+func TestPrepareDockerBuildContextInternal_StagesDockerfileExcludedByDockerignore(t *testing.T) {
+ contextDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(contextDir, "Dockerfile"), []byte("FROM alpine:3.20\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(contextDir, ".dockerignore"), []byte("**/Dockerfile*\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(contextDir, "app.txt"), []byte("hello\n"), 0o644))
+
+ req := imagetypes.BuildRequest{
+ ContextDir: contextDir,
+ Dockerfile: "Dockerfile",
+ }
+
+ input, reportProgress, err := prepareDockerBuildInputInternal(req)
+ require.NoError(t, err)
+ assert.False(t, reportProgress)
+
+ buildContextDir, dockerfileForBuild, cleanup, err := prepareDockerBuildContextInternal(input)
+ require.NoError(t, err)
+ defer cleanup()
+
+ assert.NotEqual(t, contextDir, buildContextDir)
+ assert.Equal(t, ".arcane.external.Dockerfile", dockerfileForBuild)
+
+ contents, err := os.ReadFile(filepath.Join(buildContextDir, dockerfileForBuild))
+ require.NoError(t, err)
+ assert.Equal(t, "FROM alpine:3.20\n", string(contents))
+
+ appContents, err := os.ReadFile(filepath.Join(buildContextDir, "app.txt"))
+ require.NoError(t, err)
+ assert.Equal(t, "hello\n", string(appContents))
+}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 020bfaa5c..8a6c6b4b0 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -2041,8 +2041,17 @@
"builds": "Builds",
"manual_build_workspace": "Build Workspace",
"manual_build_workspace_subtitle": "Build Container Images for local use or push to a registry",
- "build_workspace_files": "Build workspace files",
+ "build_context_mode_workspace": "Workspace",
"build_configuration": "Build configuration",
+ "build_context_mode_remote_git": "Remote Git",
+ "remote_source": "Remote source",
+ "build_remote_git_context_title": "Remote Git context",
+ "build_remote_git_context_description": "Use a Git URL for the build context. Fragments support `#ref` and `#ref:subdir`.",
+ "build_remote_git_context_placeholder": "https://github.com/owner/repo.git#main:docker/app",
+ "build_remote_git_examples": "Examples",
+ "build_remote_git_credential_lookup_title": "Credential lookup",
+ "build_remote_git_credential_lookup_description": "If the repository URL matches a saved Git repository, Arcane reuses its credentials. Otherwise the build runs anonymously.",
+ "build_remote_context_required": "Enter a remote Git context first.",
"clear_output": "Clear output",
"build_context": "Build context",
"build_context_set_to": "Build context set to {path}",
diff --git a/frontend/src/routes/(app)/images/builds/+page.svelte b/frontend/src/routes/(app)/images/builds/+page.svelte
index 4e9c3491f..f72aa3647 100644
--- a/frontend/src/routes/(app)/images/builds/+page.svelte
+++ b/frontend/src/routes/(app)/images/builds/+page.svelte
@@ -81,13 +81,22 @@
});
let selectedContextPath = $state('/');
+ let contextMode = $state<'workspace' | 'remote'>('workspace');
+ let remoteContextSource = $state('');
- const contextDir = $derived.by(() => {
+ const workspaceContextDir = $derived.by(() => {
const root = buildsRoot.endsWith('/') ? buildsRoot.slice(0, -1) : buildsRoot;
if (selectedContextPath === '/' || selectedContextPath === '') return root;
return `${root}${selectedContextPath.startsWith('/') ? '' : '/'}${selectedContextPath}`;
});
+ const contextDir = $derived.by(() => {
+ if (contextMode === 'remote') {
+ return remoteContextSource.trim();
+ }
+ return workspaceContextDir;
+ });
+
const formSchema = z.object({
dockerfile: z.string().optional().default(''),
tags: z.string().min(1, m.image_tags_required()),
@@ -338,7 +347,7 @@
return m.idle();
});
const buildMobileTabItems = $derived([
- { value: 'workspace', label: m.build_workspace_files() },
+ { value: 'workspace', label: m.build_context() },
{ value: 'configuration', label: m.build_configuration() },
{ value: 'output', label: m.build_output() }
]);
@@ -365,7 +374,7 @@
const buildHistoryOutputEntries = $derived.by(() => parseBuildOutput(buildHistorySelected?.output ?? ''));
function getBuildTitle(build: ImageBuildRecord) {
- return build.tags?.[0] || build.contextDir.split('/').pop() || build.contextDir;
+ return build.tags?.[0] || buildContextDisplayName(build.contextDir) || build.contextDir;
}
const buildHistoryColumns = [
@@ -595,7 +604,40 @@
return formatKeyValueMap(buildArgs);
}
+ function isGitBuildContextSource(value?: string): boolean {
+ const trimmed = value?.trim();
+ if (!trimmed) return false;
+ const base = trimmed.split('#', 1)[0]?.trim() ?? '';
+ if (!base) return false;
+ if (base.startsWith('git@')) return true;
+ try {
+ const parsed = new URL(base);
+ const protocol = parsed.protocol.toLowerCase();
+ if (protocol === 'ssh:' || protocol === 'git:') return true;
+ if (protocol === 'http:' || protocol === 'https:') {
+ return parsed.pathname.toLowerCase().endsWith('.git');
+ }
+ } catch {
+ return false;
+ }
+ return false;
+ }
+
+ function buildContextDisplayName(value?: string): string {
+ const trimmed = value?.trim();
+ if (!trimmed) return '';
+ if (!isGitBuildContextSource(trimmed)) {
+ return trimmed.split('/').pop() || trimmed;
+ }
+
+ const withoutFragment = trimmed.split('#', 1)[0] ?? trimmed;
+ const normalized = withoutFragment.endsWith('/') ? withoutFragment.slice(0, -1) : withoutFragment;
+ const repoName = normalized.split('/').pop() || normalized;
+ return repoName.replace(/\.git$/i, '');
+ }
+
function getContextPathFromBuild(build: ImageBuildRecord) {
+ if (isGitBuildContextSource(build.contextDir)) return '/';
const root = buildsRoot.endsWith('/') ? buildsRoot.slice(0, -1) : buildsRoot;
if (!build.contextDir || build.contextDir === root) return '/';
if (build.contextDir.startsWith(`${root}/`)) {
@@ -717,7 +759,14 @@
build.noCache ||
build.pull
);
- selectedContextPath = getContextPathFromBuild(build);
+ if (isGitBuildContextSource(build.contextDir)) {
+ contextMode = 'remote';
+ remoteContextSource = build.contextDir;
+ } else {
+ contextMode = 'workspace';
+ remoteContextSource = '';
+ selectedContextPath = getContextPathFromBuild(build);
+ }
mainTab = 'build';
rightPanelTab = 'config';
buildTab = 'configuration';
@@ -729,7 +778,7 @@
if (!data) return;
if (!contextDir || contextDir.trim() === '') {
- toast.error(m.build_context_required());
+ toast.error(contextMode === 'remote' ? m.build_remote_context_required() : m.build_context_required());
return;
}
@@ -1315,7 +1364,11 @@
<BuildWorkspacePanel
rootLabel={buildsRootLabel}
rootPath={buildsRoot}
+ {contextMode}
{contextDir}
+ remoteContext={remoteContextSource}
+ onModeChange={(mode) => (contextMode = mode)}
+ onRemoteContextChange={(value: string) => (remoteContextSource = value)}
onSelectContext={(path: string) => (selectedContextPath = path)}
/>
</Card.Root>
@@ -1389,7 +1442,11 @@
<BuildWorkspacePanel
rootLabel={buildsRootLabel}
rootPath={buildsRoot}
+ {contextMode}
{contextDir}
+ remoteContext={remoteContextSource}
+ onModeChange={(mode) => (contextMode = mode)}
+ onRemoteContextChange={(value: string) => (remoteContextSource = value)}
onSelectContext={(path: string) => (selectedContextPath = path)}
/>
</Card.Root>
diff --git a/frontend/src/routes/(app)/images/builds/components/build-workspace-panel.svelte b/frontend/src/routes/(app)/images/builds/components/build-workspace-panel.svelte
index aac001f5d..617aba001 100644
--- a/frontend/src/routes/(app)/images/builds/components/build-workspace-panel.svelte
+++ b/frontend/src/routes/(app)/images/builds/components/build-workspace-panel.svelte
@@ -10,12 +10,20 @@
let {
rootLabel,
rootPath,
+ contextMode,
contextDir,
+ remoteContext,
+ onModeChange,
+ onRemoteContextChange,
onSelectContext
}: {
rootLabel: string;
rootPath: string;
+ contextMode: 'workspace' | 'remote';
contextDir: string;
+ remoteContext: string;
+ onModeChange?: (mode: 'workspace' | 'remote') => void;
+ onRemoteContextChange?: (value: string) => void;
onSelectContext?: (path: string) => void;
} = $props();
@@ -32,32 +40,108 @@
<div class="flex h-full flex-col">
<div class="relative border-b border-zinc-800/50 bg-gradient-to-r from-zinc-900/50 to-transparent px-4 py-3">
<div class="absolute inset-0 bg-gradient-to-br from-blue-500/5 via-transparent to-transparent"></div>
- <div class="relative flex items-center justify-between">
- <div class="flex items-center gap-3">
- <div
- class="flex size-9 items-center justify-center rounded-lg bg-gradient-to-br from-blue-500/20 to-cyan-500/10 ring-1 ring-blue-400/20"
- >
- <FolderOpenIcon class="size-4 text-blue-400" />
- </div>
- <div>
- <h2 class="text-sm font-semibold tracking-tight">{m.build_workspace_files()}</h2>
- <p
- class="text-muted-foreground mt-0.5 max-w-[220px] truncate text-xs sm:max-w-[280px] lg:max-w-[360px]"
- title={contextDir}
+ <div class="relative flex flex-col gap-3">
+ <div class="flex items-center justify-between gap-3">
+ <div class="flex items-center gap-3">
+ <div
+ class="flex size-9 items-center justify-center rounded-lg bg-gradient-to-br from-blue-500/20 to-cyan-500/10 ring-1 ring-blue-400/20"
>
- {m.build_context()}: {contextDir}
- </p>
+ <FolderOpenIcon class="size-4 text-blue-400" />
+ </div>
+ <div>
+ <h2 class="text-sm font-semibold tracking-tight">{m.build_context()}</h2>
+ <p
+ class="text-muted-foreground mt-0.5 max-w-[220px] truncate text-xs sm:max-w-[280px] lg:max-w-[360px]"
+ title={contextDir}
+ >
+ {contextMode === 'remote' ? `${m.remote_source()}` : `${m.build_context()}:`}
+ {contextDir}
+ </p>
+ </div>
</div>
+ <ArcaneButton action="base" tone="ghost" size="sm" onclick={() => goto('/settings/builds')} class="hover:bg-white/5">
+ <SettingsIcon class="size-4" />
+ </ArcaneButton>
+ </div>
+
+ <div class="flex items-center gap-2 rounded-lg border border-zinc-800/70 bg-zinc-950/50 p-1">
+ <button
+ type="button"
+ class={`flex-1 rounded-md px-3 py-2 text-xs font-medium transition-colors ${
+ contextMode === 'workspace'
+ ? 'bg-blue-500/12 text-blue-100 ring-1 ring-blue-400/20'
+ : 'text-muted-foreground hover:text-foreground'
+ }`}
+ onclick={() => onModeChange?.('workspace')}
+ >
+ {m.build_context_mode_workspace()}
+ </button>
+ <button
+ type="button"
+ class={`flex-1 rounded-md px-3 py-2 text-xs font-medium transition-colors ${
+ contextMode === 'remote'
+ ? 'bg-emerald-500/12 text-emerald-100 ring-1 ring-emerald-400/20'
+ : 'text-muted-foreground hover:text-foreground'
+ }`}
+ onclick={() => onModeChange?.('remote')}
+ >
+ {m.build_context_mode_remote_git()}
+ </button>
</div>
- <ArcaneButton action="base" tone="ghost" size="sm" onclick={() => goto('/settings/builds')} class="hover:bg-white/5">
- <SettingsIcon class="size-4" />
- </ArcaneButton>
</div>
</div>
<div class="flex min-h-0 flex-1 flex-col overflow-hidden">
<div class="flex min-h-0 flex-1 flex-col p-4">
- <BuildWorkspaceBrowser {provider} {rootLabel} {rootPath} onSelectContext={(path: string) => onSelectContext?.(path)} />
+ {#if contextMode === 'workspace'}
+ <BuildWorkspaceBrowser {provider} {rootLabel} {rootPath} onSelectContext={(path: string) => onSelectContext?.(path)} />
+ {:else}
+ <div
+ class="flex h-full flex-col rounded-2xl border border-emerald-500/20 bg-gradient-to-br from-emerald-500/8 via-zinc-950 to-zinc-950 p-5"
+ >
+ <div class="max-w-xl space-y-2">
+ <p class="text-sm font-semibold text-emerald-100">{m.build_remote_git_context_title()}</p>
+ <p class="text-muted-foreground text-sm">
+ {m.build_remote_git_context_description()}
+ </p>
+ </div>
+
+ <div class="mt-5 space-y-3">
+ <label for="remote-context-url" class="text-xs font-medium tracking-[0.12em] text-zinc-400 uppercase">
+ {m.git_repository_url()}
+ </label>
+ <input
+ id="remote-context-url"
+ type="text"
+ value={remoteContext}
+ oninput={(event) => onRemoteContextChange?.((event.currentTarget as HTMLInputElement).value)}
+ placeholder={m.build_remote_git_context_placeholder()}
+ class="border-border bg-background/80 focus-visible:ring-ring w-full rounded-xl border px-4 py-3 text-sm transition outline-none focus-visible:ring-2"
+ spellcheck="false"
+ autocomplete="off"
+ />
+ </div>
+
+ <div class="mt-5 grid gap-3 text-xs text-zinc-400 sm:grid-cols-2">
+ <div class="rounded-xl border border-zinc-800/70 bg-zinc-950/60 p-3">
+ <div class="font-medium text-zinc-200">{m.build_remote_git_examples()}</div>
+ <div class="mt-2 font-mono leading-5 break-all">
+ https://github.com/owner/repo.git
+ <br />
+ https://github.com/owner/repo.git#main
+ <br />
+ https://github.com/owner/repo.git#main:docker/app
+ </div>
+ </div>
+ <div class="rounded-xl border border-zinc-800/70 bg-zinc-950/60 p-3">
+ <div class="font-medium text-zinc-200">{m.build_remote_git_credential_lookup_title()}</div>
+ <div class="mt-2 leading-5">
+ {m.build_remote_git_credential_lookup_description()}
+ </div>
+ </div>
+ </div>
+ </div>
+ {/if}
</div>
</div>
</div>
diff --git a/tests/spec/builds.spec.ts b/tests/spec/builds.spec.ts
index 2179df625..1a321993b 100644
--- a/tests/spec/builds.spec.ts
+++ b/tests/spec/builds.spec.ts
@@ -37,6 +37,10 @@ async function setRequiredBuildInputs(page: Page, tags = `e2e/build:${Date.now()
await tagsInput.fill(tags);
}
+async function switchContextMode(page: Page, mode: "Workspace" | "Remote Git"): Promise<void> {
+ await page.getByRole("button", { name: mode, exact: true }).first().click();
+}
+
async function openAdvancedBuildOptions(page: Page) {
const dockerfileInput = page.locator("#dockerfile");
const alreadyVisible = await dockerfileInput.isVisible().catch(() => false);
@@ -131,6 +135,28 @@ async function mockDepotConfiguredSettings(page: Page) {
}
test.describe("Build workspace provider flows", () => {
+ test("submits remote git build context from the dedicated context mode", async ({ page }) => {
+ await navigateToBuildWorkspace(page);
+ await switchContextMode(page, "Remote Git");
+ await page.locator("#remote-context-url").fill("https://github.com/getarcaneapp/arcane.git#main:docker/app");
+ await setRequiredBuildInputs(page, `e2e/remote:${Date.now()}`);
+
+ let buildPayload: Record<string, unknown> | null = null;
+ await page.route("**/api/environments/*/images/build", async (route) => {
+ buildPayload = route.request().postDataJSON() as Record<string, unknown>;
+ await route.fulfill({
+ status: 200,
+ contentType: "application/x-ndjson",
+ body: STREAM_SUCCESS,
+ });
+ });
+
+ await getBuildButton(page).click();
+ await expect.poll(() => buildPayload, { timeout: 10000 }).not.toBeNull();
+
+ expect(buildPayload?.contextDir).toBe("https://github.com/getarcaneapp/arcane.git#main:docker/app");
+ });
+
test("submits local provider build payload from UI controls", async ({ page }) => {
await navigateToBuildWorkspace(page);
await setRequiredBuildInputs(page);
diff --git a/types/image/image.go b/types/image/image.go
index b5d73c99b..dc8d05173 100644
--- a/types/image/image.go
+++ b/types/image/image.go
@@ -247,10 +247,11 @@ type ProgressEvent struct {
// BuildRequest contains options for building an image with BuildKit.
type BuildRequest struct {
- // ContextDir is the build context directory on the server.
+ // ContextDir is the build context source.
+ // This can be a local server directory or a supported Git URL.
//
// Required: true
- ContextDir string `json:"contextDir" minLength:"1" doc:"Build context directory"`
+ ContextDir string `json:"contextDir" minLength:"1" doc:"Build context directory or Git URL"`
// Dockerfile is the path to the Dockerfile (relative to context or absolute).
//