fix(isolation): apply the configured registry to namespaced images (#1759)

## Bug

`docker_isolation.registry` is documented as the custom registry for
isolation images, and air-gapped installs depend on it (see
`isolation_git_image_registry_test.go`). `buildFullImageName` treats any
image containing a `/` as already qualified and returns it unchanged. A
Docker Hub namespaced image such as `myorg/node-mcp:1` therefore
bypasses the configured registry and is pulled from docker.io. The final
`registry + "/" + image` branch is unreachable.

Docker's own rule is that the first path component is a registry host
only if it contains `.` or `:`, or is `localhost`. Otherwise it is a
Docker Hub namespace.

## Trigger

```json
"docker_isolation": {
  "enabled": true,
  "registry": "mirror.corp",
  "default_images": {"node": "myorg/node-mcp:1"}
}
```

A per-server `isolation.image: "myorg/node-mcp:1"` triggers it too.

- Expected image: `mirror.corp/myorg/node-mcp:1`.
- Actual image: `myorg/node-mcp:1`, which a host without internet access
cannot pull.

## Fix

Use Docker's host rule (`imageHasRegistryHost`) to decide whether a
reference is already qualified. With a custom registry configured,
namespaced images get the registry prefix like official images already
do. With no registry configured, `org/image` is still returned
unchanged, so ordinary installs see no difference. Fully qualified
references (`ghcr.io/...`, `localhost:5000/...`,
`registry.local/...@sha256:...`) are untouched.

## Test

`TestBuildFullImageName_ConfiguredRegistryPrefixesNamespacedImages` is a
table test covering the configured-registry and no-registry cases above.

## Commands run

- `CGO_ENABLED=0 go test -count=1 ./internal/upstream/core`: ok
(includes the existing git-image registry tests)
- With the fix reverted (`git stash` of `isolation.go`), the new test
fails with `buildFullImageName("myorg/node-mcp:1") = "myorg/node-mcp:1",
want "mirror.corp/myorg/node-mcp:1"`.
- `gofmt -l` on the edited files: no output

Author: rudycelekli

internal/upstream/core/isolation.go

@@ -472,8 +472,13 @@ func (im *IsolationManager) ResolveDefaults(serverConfig *config.ServerConfig) *
 
 // buildFullImageName constructs the full image name with registry if needed
 func (im *IsolationManager) buildFullImageName(image string) string {
-	// If image already contains a registry (has a slash before the first colon), use as-is
-	if strings.Contains(image, "/") && strings.Index(image, "/") < strings.Index(image, ":") {
+	if imageHasRegistryHost(image) {
+		return image
+	}
+
+	// Without a configured registry, a namespaced Docker Hub reference
+	// (org/image) is already pullable as written.
+	if im.globalConfig.Registry == "" && strings.Contains(image, "/") {
 		return image
 	}
 
@@ -483,11 +488,6 @@ func (im *IsolationManager) buildFullImageName(image string) string {
 		registry = "docker.io"
 	}
 
-	// Don't prepend registry if image already contains one
-	if strings.Contains(image, "/") {
-		return image
-	}
-
 	// For official images (no slash), prepend library/
 	if !strings.Contains(image, "/") {
 		return fmt.Sprintf("%s/library/%s", registry, image)
@@ -496,6 +496,18 @@ func (im *IsolationManager) buildFullImageName(image string) string {
 	return fmt.Sprintf("%s/%s", registry, image)
 }
 
+// imageHasRegistryHost applies Docker's reference rule: the first path
+// component names a registry only if it contains '.' or ':' or is
+// "localhost"; otherwise it is a Docker Hub namespace (org/image).
+func imageHasRegistryHost(image string) bool {
+	i := strings.Index(image, "/")
+	if i < 0 {
+		return false
+	}
+	host := image[:i]
+	return strings.ContainsAny(host, ".:") || host == "localhost"
+}
+
 // BuildDockerArgs constructs Docker run arguments for isolation
 func (im *IsolationManager) BuildDockerArgs(serverConfig *config.ServerConfig, runtimeType string) ([]string, error) {
 	image, err := im.GetDockerImage(serverConfig, runtimeType)

internal/upstream/core/isolation_registry_namespace_test.go

@@ -0,0 +1,30 @@
+package core
+
+import "testing"
+
+func TestBuildFullImageName_ConfiguredRegistryPrefixesNamespacedImages(t *testing.T) {
+	mirror := registryOnlyManager("mirror.corp", nil)
+	cases := map[string]string{
+		"myorg/node-mcp:1":              "mirror.corp/myorg/node-mcp:1",
+		"python:3.11":                   "mirror.corp/library/python:3.11",
+		"ghcr.io/org/img:2":             "ghcr.io/org/img:2",
+		"localhost:5000/team/img":       "localhost:5000/team/img",
+		"localhost/team/img":            "localhost/team/img",
+		"registry.local/img@sha256:abc": "registry.local/img@sha256:abc",
+	}
+	for in, want := range cases {
+		if got := mirror.buildFullImageName(in); got != want {
+			t.Errorf("registry=mirror.corp: buildFullImageName(%q) = %q, want %q", in, got, want)
+		}
+	}
+
+	plain := registryOnlyManager("", nil)
+	for in, want := range map[string]string{
+		"myorg/node-mcp:1": "myorg/node-mcp:1",
+		"python:3.11":      "docker.io/library/python:3.11",
+	} {
+		if got := plain.buildFullImageName(in); got != want {
+			t.Errorf("no registry: buildFullImageName(%q) = %q, want %q", in, got, want)
+		}
+	}
+}