fix(config): port upstream #1213 (colon defaults) and #1261 (worktree custom mount)

#1213: a ${localEnv:VAR:default} default value may itself contain colons (URLs,
image:tag, host:port). resolveEnvTag now rejoins the parts after the variable
name instead of dropping everything past the first colon.

#1261: when the config sets a custom workspaceMount, the Git worktree common-dir
mount is now resolved relative to that (substituted) mount target instead of the
auto-computed container folder, so git works in the container for monorepo
setups with a custom workspaceMount/workspaceFolder.

Both are the same bugs the Go port inherited from the pre-fix reference. Tests
added.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: aledbf

internal/config/loader.go

@@ -343,7 +343,15 @@ func computeWorkspaceConfig(workspace *Workspace, config *DevContainer, mountWor
 	containerMountFolder := "/workspaces/" + filepath.Base(sourceFolder)
 	var additionalMounts []string
 	if mountWorkspaceGitRoot && mountGitWorktreeCommonDir && !config.IsComposeConfig() {
-		if remapped, commonDirMount, ok := gitWorktreeCommonDirMount(sourceFolder, consistency); ok {
+		// A custom workspaceMount defines where the worktree is actually mounted in
+		// the container; resolve the common dir relative to that (substituted)
+		// target so the relative gitdir still resolves. Otherwise fall back to the
+		// computed container mount folder (#1261).
+		customTarget := ""
+		if config.WorkspaceMount != "" {
+			customTarget = substituteHostString(workspace, mountTarget(config.WorkspaceMount))
+		}
+		if remapped, commonDirMount, ok := gitWorktreeCommonDirMount(sourceFolder, customTarget, consistency); ok {
 			containerMountFolder = remapped
 			additionalMounts = append(additionalMounts, commonDirMount)
 		}
@@ -402,7 +410,7 @@ func bindMount(source, target, consistency string) string {
 // the shared common dir (the main repo's `.git`) into the container. ok is false
 // for a normal clone (`.git` is a directory), an absolute gitdir, or a missing
 // gitlink — all cases where no extra mount is needed.
-func gitWorktreeCommonDirMount(hostMountFolder, consistency string) (containerMountFolder, additionalMount string, ok bool) {
+func gitWorktreeCommonDirMount(hostMountFolder, customContainerTarget, consistency string) (containerMountFolder, additionalMount string, ok bool) {
 	info, err := os.Stat(filepath.Join(hostMountFolder, ".git"))
 	if err != nil || !info.Mode().IsRegular() {
 		return "", "", false
@@ -429,11 +437,68 @@ func gitWorktreeCommonDirMount(hostMountFolder, consistency string) (containerMo
 	}
 	containerMountFolder = path.Join(append([]string{"/workspaces"}, segments...)...)
 
-	// The common dir lands at the same relative offset inside the container.
-	containerGitCommonDir := path.Clean(path.Join(containerMountFolder, filepath.ToSlash(gitdir), "..", ".."))
+	// The common dir lands at the same relative offset from wherever the worktree
+	// is mounted: a custom workspaceMount target when the config sets one, else the
+	// computed container mount folder.
+	worktreeContainerFolder := containerMountFolder
+	if customContainerTarget != "" {
+		worktreeContainerFolder = customContainerTarget
+	}
+	containerGitCommonDir := path.Clean(path.Join(worktreeContainerFolder, filepath.ToSlash(gitdir), "..", ".."))
 	return containerMountFolder, bindMount(gitCommonDir, containerGitCommonDir, consistency), true
 }
 
+// mountTarget extracts the target= value from a `type=bind,...` mount spec,
+// tolerating a quoted source/target that itself contains commas.
+func mountTarget(spec string) string {
+	for _, f := range splitMountFields(spec) {
+		if t, ok := strings.CutPrefix(f, "target="); ok {
+			return t
+		}
+	}
+	return ""
+}
+
+// splitMountFields splits a docker mount spec on commas that are not inside
+// double quotes, stripping the quotes.
+func splitMountFields(spec string) []string {
+	var fields []string
+	var b strings.Builder
+	inQuote := false
+	for _, r := range spec {
+		switch {
+		case r == '"':
+			inQuote = !inQuote
+		case r == ',' && !inQuote:
+			fields = append(fields, b.String())
+			b.Reset()
+		default:
+			b.WriteRune(r)
+		}
+	}
+	return append(fields, b.String())
+}
+
+// substituteHostString applies host-phase variable substitution to s using a
+// minimal host context (platform, local workspace folder, env). Used for the
+// custom workspaceMount target, which is resolved before the main substitution
+// pass. Returns s unchanged on error or when it has no ${...} tags.
+func substituteHostString(workspace *Workspace, s string) string {
+	if !strings.Contains(s, "${") {
+		return s
+	}
+	ctx := HostSubContext{
+		Platform:             currentPlatform(),
+		LocalWorkspaceFolder: strings.TrimRight(workspace.RootFolderPath, "/\\"),
+		Env:                  envFromOS(),
+	}
+	out, err := NewVariableResolver().resolveString(SubstitutionContext{HostSubContext: ctx}, PhaseHost, s)
+	if err != nil {
+		return s
+	}
+	return out
+}
+
 // parseGitdir extracts the target of a `gitdir: <path>` line from a `.git`
 // gitlink file. No regexp, matching the rest of the package.
 func parseGitdir(content string) (string, bool) {

internal/config/varsub.go

@@ -243,7 +243,10 @@ func resolveEnvTag(isWin bool, env map[string]string, args []string, tag, config
 		return value, true, nil
 	}
 	if len(args) > 1 {
-		return args[1], true, nil
+		// Rejoin the remaining parts so a default value may itself contain colons
+		// (e.g. ${localEnv:REG:my.registry.io:5000/img}); only the first colon
+		// separates the variable name from its default.
+		return strings.Join(args[1:], ":"), true, nil
 	}
 	return "", true, nil
 }

internal/config/varsub_test.go

@@ -95,6 +95,10 @@ func TestVariableResolverHostPhase(t *testing.T) {
 		{"localEnv with suffix", localEnvCtx, "${localEnv:HOME}/project", "/home/user/project"},
 		{"localEnv missing", localEnvCtx, "${localEnv:MISSING}", ""},
 		{"localEnv missing with fallback", localEnvCtx, "${localEnv:MISSING:fallback}", "fallback"},
+		// A default value may itself contain colons (URLs, image:tag, host:port) —
+		// only the first colon separates the var name from its default (#1213).
+		{"localEnv fallback with colons", localEnvCtx, "${localEnv:MISSING:my.registry.io:5000/img:tag}", "my.registry.io:5000/img:tag"},
+		{"localEnv present ignores colon fallback", localEnvCtx, "${localEnv:HOME:a:b:c}", "/home/user"},
 		{"no vars", localEnvCtx, "no vars here", "no vars here"},
 		{"multiple localEnv", localEnvCtx, "${localEnv:USER}@${localEnv:HOME}", "test@/home/user"},
 

internal/config/worktree_test.go

@@ -196,3 +196,70 @@ func TestLoadDevContainerConfigWithMountsWorktree(t *testing.T) {
 		t.Errorf("default load AdditionalMounts = %q, want none", res2.WorkspaceConfig.AdditionalMounts)
 	}
 }
+
+// TestWorktreeCommonDirCustomWorkspaceMount ports upstream #1261: when the config
+// sets a custom workspaceMount/workspaceFolder, the common-dir mount is still
+// added, with its target resolved relative to the custom mount target.
+func TestWorktreeCommonDirCustomWorkspaceMount(t *testing.T) {
+	if runtime.GOOS != "linux" {
+		t.Skip("oracle pins the linux consistency behavior (empty suffix)")
+	}
+
+	t.Run("common dir target relative to custom mount", func(t *testing.T) {
+		base := t.TempDir()
+		wt := writeGitlink(t, base, "worktrees/feature", "gitdir: ../main/.git/worktrees/feature")
+		mainGit := filepath.Join(base, "worktrees", "main", ".git")
+
+		wc := computeWorkspaceConfig(&Workspace{RootFolderPath: wt}, &DevContainer{
+			WorkspaceMount:  "type=bind,source=/host/wt,target=/workspace",
+			WorkspaceFolder: "/workspace",
+		}, true, true)
+
+		// Custom mount/folder respected verbatim; common dir mounted, target
+		// resolved relative to /workspace → /main/.git.
+		if wc.WorkspaceMount != "type=bind,source=/host/wt,target=/workspace" {
+			t.Errorf("workspaceMount = %q", wc.WorkspaceMount)
+		}
+		if wc.WorkspaceFolder != "/workspace" {
+			t.Errorf("workspaceFolder = %q", wc.WorkspaceFolder)
+		}
+		want := "type=bind,source=" + mainGit + ",target=/main/.git"
+		if len(wc.AdditionalMounts) != 1 || wc.AdditionalMounts[0] != want {
+			t.Errorf("additionalMounts = %q, want [%q]", wc.AdditionalMounts, want)
+		}
+	})
+
+	t.Run("variables in the custom mount target are substituted", func(t *testing.T) {
+		base := t.TempDir()
+		wt := writeGitlink(t, base, "worktrees/feature", "gitdir: ../main/.git/worktrees/feature")
+		mainGit := filepath.Join(base, "worktrees", "main", ".git")
+
+		// target uses ${localWorkspaceFolderBasename} → "feature".
+		wc := computeWorkspaceConfig(&Workspace{RootFolderPath: wt}, &DevContainer{
+			WorkspaceMount:  "type=bind,source=/host/wt,target=/src/${localWorkspaceFolderBasename}",
+			WorkspaceFolder: "/src/feature",
+		}, true, true)
+
+		// common dir resolved relative to the substituted target /src/feature →
+		// /src/main/.git.
+		want := "type=bind,source=" + mainGit + ",target=/src/main/.git"
+		if len(wc.AdditionalMounts) != 1 || wc.AdditionalMounts[0] != want {
+			t.Errorf("additionalMounts = %q, want [%q]", wc.AdditionalMounts, want)
+		}
+	})
+}
+
+func TestMountTarget(t *testing.T) {
+	cases := map[string]string{
+		"type=bind,source=/a,target=/b":                    "/b",
+		"type=bind,source=/a,target=/b,consistency=cached": "/b",
+		`type=bind,source="/a,x",target="/b,y"`:            "/b,y",
+		"type=volume,source=vol,target=/data":              "/data",
+		"type=bind,source=/a":                              "",
+	}
+	for spec, want := range cases {
+		if got := mountTarget(spec); got != want {
+			t.Errorf("mountTarget(%q) = %q, want %q", spec, got, want)
+		}
+	}
+}