feat(compose): use compose project name as workspace name

e2e/tests/up-docker-compose/config.go

@@ -14,8 +14,11 @@ import (
 
 	"github.com/devsy-org/devsy/e2e/framework"
 	"github.com/devsy-org/devsy/pkg/compose"
+	pkgconfig "github.com/devsy-org/devsy/pkg/config"
 	"github.com/devsy-org/devsy/pkg/devcontainer/config"
 	docker "github.com/devsy-org/devsy/pkg/docker"
+	provider2 "github.com/devsy-org/devsy/pkg/provider"
+	"github.com/docker/docker/api/types/container"
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
 )
@@ -567,6 +570,168 @@ var _ = ginkgo.Describe(
 			gomega.Expect(containerWorkspaceFolderBasename).To(gomega.Equal("workspaces"))
 		}, ginkgo.SpecTimeout(framework.TimeoutLong()))
 
+		ginkgo.Context("compose project name resolution", func() {
+			const composeProjectLabel = "com.docker.compose.project"
+
+			composeProjectFromContainer := func(
+				ctx context.Context,
+				workspace *provider2.Workspace,
+			) string {
+				name, err := composeProjectForWorkspace(
+					ctx, tc.dockerHelper, tc.composeHelper, workspace.UID,
+				)
+				framework.ExpectNoError(err)
+				gomega.Expect(name).To(gomega.Not(gomega.BeEmpty()),
+					"dev container has a "+composeProjectLabel+" label")
+				return name
+			}
+
+			devContainer := func(
+				ctx context.Context,
+				workspace *provider2.Workspace,
+			) *container.InspectResponse {
+				ids, err := tc.dockerHelper.FindContainer(ctx, []string{
+					fmt.Sprintf("%s=%s", pkgconfig.DevcontainerIDLabel, workspace.UID),
+				})
+				framework.ExpectNoError(err)
+				gomega.Expect(ids).To(gomega.HaveLen(1),
+					"exactly one dev container for the workspace")
+				detail, err := tc.inspectContainer(ctx, ids)
+				framework.ExpectNoError(err)
+				return detail
+			}
+
+			ginkgo.It("uses the top-level compose name as project name", func(ctx context.Context) {
+				_, workspace, err := tc.setupAndStartWorkspace(
+					ctx,
+					"tests/up-docker-compose/testdata/docker-compose-v2-with-name",
+				)
+				framework.ExpectNoError(err)
+
+				gomega.Expect(composeProjectFromContainer(ctx, workspace)).
+					To(gomega.Equal("testproject"),
+						"project name comes from the top-level compose name field")
+			}, ginkgo.SpecTimeout(framework.TimeoutLong()))
+
+			ginkgo.It(
+				"uses COMPOSE_PROJECT_NAME from .env as project name",
+				func(ctx context.Context) {
+					tempDir, err := setupWorkspace(
+						"tests/up-docker-compose/testdata/docker-compose-project-name-envfile",
+						tc.initialDir, tc.f,
+					)
+					framework.ExpectNoError(err)
+
+					framework.ExpectNoError(
+						os.WriteFile(
+							filepath.Join(tempDir, ".env"),
+							[]byte("COMPOSE_PROJECT_NAME=devsy-e2e-envfile-project\n"),
+							0o600,
+						),
+					)
+
+					framework.ExpectNoError(tc.f.DevsyUp(ctx, tempDir))
+
+					workspace, err := tc.f.FindWorkspace(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					gomega.Expect(composeProjectFromContainer(ctx, workspace)).
+						To(gomega.Equal("devsy-e2e-envfile-project"),
+							"project name comes from COMPOSE_PROJECT_NAME in .env")
+				},
+				ginkgo.SpecTimeout(framework.TimeoutLong()),
+			)
+
+			ginkgo.It(
+				"uses COMPOSE_PROJECT_NAME from a .env colocated with the compose file",
+				func(ctx context.Context) {
+					tempDir, err := setupWorkspace(
+						"tests/up-docker-compose/testdata/docker-compose-nested-envfile",
+						tc.initialDir, tc.f,
+					)
+					framework.ExpectNoError(err)
+
+					framework.ExpectNoError(
+						os.WriteFile(
+							filepath.Join(tempDir, "dockerfiles", ".env"),
+							[]byte("COMPOSE_PROJECT_NAME=devsy-e2e-subdir-envfile-project\n"),
+							0o600,
+						),
+					)
+
+					framework.ExpectNoError(tc.f.DevsyUp(ctx, tempDir))
+
+					workspace, err := tc.f.FindWorkspace(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					gomega.Expect(composeProjectFromContainer(ctx, workspace)).
+						To(gomega.Equal("devsy-e2e-subdir-envfile-project"),
+							"project name comes from COMPOSE_PROJECT_NAME in the "+
+								"compose file's own directory, not just the workspace root")
+				},
+				ginkgo.SpecTimeout(framework.TimeoutLong()),
+			)
+
+			ginkgo.It(
+				"uses COMPOSE_PROJECT_NAME from the shell as project name",
+				func(ctx context.Context) {
+					tempDir, err := setupWorkspace(
+						"tests/up-docker-compose/testdata/docker-compose", tc.initialDir, tc.f,
+					)
+					framework.ExpectNoError(err)
+
+					framework.ExpectNoError(
+						os.Setenv(compose.ComposeProjectNameEnv, "devsy-e2e-shell-project"),
+					)
+					ginkgo.DeferCleanup(func() {
+						framework.ExpectNoError(os.Unsetenv(compose.ComposeProjectNameEnv))
+					})
+
+					err = tc.f.DevsyUp(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					workspace, err := tc.f.FindWorkspace(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					gomega.Expect(composeProjectFromContainer(ctx, workspace)).
+						To(gomega.Equal("devsy-e2e-shell-project"),
+							"shell COMPOSE_PROJECT_NAME overrides all other sources")
+				},
+				ginkgo.SpecTimeout(framework.TimeoutLong()),
+			)
+
+			ginkgo.It(
+				"reuses the existing compose project on a second up",
+				func(ctx context.Context) {
+					tempDir, err := setupWorkspace(
+						"tests/up-docker-compose/testdata/docker-compose-v2-with-name",
+						tc.initialDir, tc.f,
+					)
+					framework.ExpectNoError(err)
+
+					err = tc.f.DevsyUp(ctx, tempDir)
+					framework.ExpectNoError(err)
+					workspace, err := tc.f.FindWorkspace(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					firstProject := composeProjectFromContainer(ctx, workspace)
+					firstID := devContainer(ctx, workspace).ID
+
+					err = tc.f.DevsyUp(ctx, tempDir)
+					framework.ExpectNoError(err)
+
+					secondProject := composeProjectFromContainer(ctx, workspace)
+					secondID := devContainer(ctx, workspace).ID
+
+					gomega.Expect(secondProject).To(gomega.Equal(firstProject),
+						"second up reuses the same compose project name")
+					gomega.Expect(secondID).To(gomega.Equal(firstID),
+						"second up reuses the same container (no separate project spawned)")
+				},
+				ginkgo.SpecTimeout(framework.TimeoutLong()),
+			)
+		})
+
 		ginkgo.Context("host requirements enforcement", func() {
 			var btc *baseTestContext
 

e2e/tests/up-docker-compose/helper.go

@@ -186,22 +186,53 @@ func setupDockerProvider(binDir string) (*framework.Framework, error) {
 	return framework.SetupDockerProvider(binDir, "docker")
 }
 
+// findComposeContainer returns the compose container IDs for a workspace's
+// service, resolving devsy's actual project name first since it may not be
+// the sanitized workspace UID.
 func findComposeContainer(
 	ctx context.Context,
 	dockerHelper *docker.DockerHelper,
 	composeHelper *compose.ComposeHelper,
 	workspaceUID, serviceName string,
 ) ([]string, error) {
+	projectName, err := composeProjectForWorkspace(ctx, dockerHelper, composeHelper, workspaceUID)
+	if err != nil {
+		return nil, err
+	}
 	return dockerHelper.FindContainer(ctx, []string{
-		fmt.Sprintf(
-			"%s=%s",
-			pkgconfig.ComposeProjectLabel,
-			composeHelper.GetProjectName(workspaceUID),
-		),
+		fmt.Sprintf("%s=%s", pkgconfig.ComposeProjectLabel, projectName),
 		fmt.Sprintf("%s=%s", pkgconfig.ComposeServiceLabel, serviceName),
 	})
 }
 
+// composeProjectForWorkspace resolves the compose project name devsy used
+// for the workspace by inspecting its dev container's labels, falling back
+// to the sanitized workspace UID when none is found.
+func composeProjectForWorkspace(
+	ctx context.Context,
+	dockerHelper *docker.DockerHelper,
+	composeHelper *compose.ComposeHelper,
+	workspaceUID string,
+) (string, error) {
+	devIDs, err := dockerHelper.FindContainer(ctx, []string{
+		fmt.Sprintf("%s=%s", pkgconfig.DevcontainerIDLabel, workspaceUID),
+	})
+	if err != nil {
+		return "", err
+	}
+	if len(devIDs) == 0 {
+		return composeHelper.GetProjectName(workspaceUID), nil
+	}
+	var dev []container.InspectResponse
+	if err := dockerHelper.Inspect(ctx, devIDs[:1], "container", &dev); err != nil {
+		return "", err
+	}
+	if name, ok := dev[0].Config.Labels[pkgconfig.ComposeProjectLabel]; ok {
+		return name, nil
+	}
+	return composeHelper.GetProjectName(workspaceUID), nil
+}
+
 func devsyUpAndFindWorkspace(
 	ctx context.Context,
 	f *framework.Framework,

e2e/tests/up-docker-compose/testdata/docker-compose-nested-envfile/.devcontainer/devcontainer.json

@@ -0,0 +1,6 @@
+{
+  "name": "Compose project name from subdirectory .env",
+  "dockerComposeFile": "../dockerfiles/docker-compose.yaml",
+  "service": "app",
+  "workspaceFolder": "/workspaces"
+}

e2e/tests/up-docker-compose/testdata/docker-compose-nested-envfile/dockerfiles/docker-compose.yaml

@@ -0,0 +1,4 @@
+services:
+  app:
+    image: ghcr.io/devsy-org/test-images/base:ubuntu
+    command: sleep infinity

e2e/tests/up-docker-compose/testdata/docker-compose-project-name-envfile/.devcontainer/devcontainer.json

@@ -0,0 +1,6 @@
+{
+  "name": "Compose project name from .env",
+  "dockerComposeFile": "../docker-compose.yaml",
+  "service": "app",
+  "workspaceFolder": "/workspaces"
+}

e2e/tests/up-docker-compose/testdata/docker-compose-project-name-envfile/docker-compose.yaml

@@ -0,0 +1,4 @@
+services:
+  app:
+    image: ghcr.io/devsy-org/test-images/base:ubuntu
+    command: sleep infinity

pkg/compose/helper.go

@@ -364,6 +364,13 @@ func (h *ComposeHelper) GetProjectName(runnerID string) string {
 	return h.toProjectName(runnerID)
 }
 
+// SanitizeProjectName exposes toProjectName's compose-version-aware
+// sanitization for callers outside this package (e.g. the devsy runner id
+// fallback for compose project names).
+func (h *ComposeHelper) SanitizeProjectName(name string) string {
+	return h.toProjectName(name)
+}
+
 func (h *ComposeHelper) toProjectName(projectName string) string {
 	useNewProjectNameFormat, _ := h.useNewProjectName()
 	if !useNewProjectNameFormat {

pkg/compose/projectname.go

@@ -0,0 +1,60 @@
+package compose
+
+import (
+	"os"
+
+	"github.com/joho/godotenv"
+	"gopkg.in/yaml.v3"
+)
+
+// ComposeProjectNameEnv is the environment/file variable Docker Compose uses
+// to override the project name: https://docs.docker.com/compose/how-tos/project-name/
+const ComposeProjectNameEnv = "COMPOSE_PROJECT_NAME"
+
+// ProjectNameFromEnvFiles returns the first non-empty COMPOSE_PROJECT_NAME
+// found scanning envFiles in order. Missing files are skipped.
+func ProjectNameFromEnvFiles(envFiles []string) (string, error) {
+	for _, envFile := range envFiles {
+		env, err := godotenv.Read(envFile)
+		if err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return "", err
+		}
+		if name := env[ComposeProjectNameEnv]; name != "" {
+			return name, nil
+		}
+	}
+	return "", nil
+}
+
+// composeNameFile is the subset of a compose file relevant to name detection.
+type composeNameFile struct {
+	Name string `yaml:"name"`
+}
+
+// ComposeFilesDeclareName reports whether any compose file declares a
+// top-level "name" (mirroring compose-go's own isNamed check). Presence is
+// all that's needed: the caller uses the already-loaded project's
+// interpolated Name when this is true.
+func ComposeFilesDeclareName(composeFiles []string) (bool, error) {
+	for _, file := range composeFiles {
+		// #nosec G304 -- file paths are resolved from the trusted devcontainer config.
+		b, err := os.ReadFile(file)
+		if err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return false, err
+		}
+		var parsed composeNameFile
+		if err := yaml.Unmarshal(b, &parsed); err != nil {
+			continue
+		}
+		if parsed.Name != "" {
+			return true, nil
+		}
+	}
+	return false, nil
+}