Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: incorrect ipv6 parsing on api responses (#2040)
Kyle Mendelld54cc6fed7ce
diff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.goindex 2fdb9373b..483f333d8 100644--- a/backend/cli/upgrade/upgrade.go+++ b/backend/cli/upgrade/upgrade.go@@ -83,7 +83,7 @@ func runUpgrade(cmd *cobra.Command, args []string) error {containerName = strings.TrimPrefix(targetContainer.Name, "/")slog.Info("Found Arcane container", "name", containerName, "id", targetContainer.ID[:12])} else {- inspectResult, inspectErr := dockerClient.ContainerInspect(ctx, containerName, client.ContainerInspectOptions{})+ inspectResult, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerName, client.ContainerInspectOptions{})targetContainer = inspectResult.Containererr = inspectErrif err != nil {@@ -134,7 +134,7 @@ func findArcaneContainer(ctx context.Context, dockerClient *client.Client) (contcontinue}- inspectResult, err := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})if err != nil {continue}diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.goindex 58d5b5668..e6e0d87c3 100644--- a/backend/internal/services/container_service.go+++ b/backend/internal/services/container_service.go@@ -124,7 +124,7 @@ func (s *ContainerService) GetContainerByID(ctx context.Context, id string) (*coreturn nil, fmt.Errorf("failed to connect to Docker: %w", err)}- containerInspect, err := dockerClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})+ containerInspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, id, client.ContainerInspectOptions{})if err != nil {return nil, fmt.Errorf("container not found: %w", err)}@@ -143,7 +143,7 @@ func (s *ContainerService) DeleteContainer(ctx context.Context, containerID stri// Get container mounts before deletion if we need to remove volumesvar volumesToRemove []stringif removeVolumes {- containerJSON, inspectErr := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})+ containerJSON, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})if inspectErr == nil {for _, mount := range containerJSON.Container.Mounts {// Only collect named volumes (not bind mounts or tmpfs)@@ -253,7 +253,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containereturn nil, fmt.Errorf("failed to start container: %w", err)}- containerJSON, err := dockerClient.ContainerInspect(ctx, resp.ID, client.ContainerInspectOptions{})+ containerJSON, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, resp.ID, client.ContainerInspectOptions{})if err != nil {s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", resp.ID, containerName, user.ID, user.Username, "0", err, models.JSON{"action": "create", "image": config.Image, "step": "inspect"})return nil, fmt.Errorf("failed to inspect created container: %w", err)diff --git a/backend/internal/services/network_service.go b/backend/internal/services/network_service.goindex 0780a2088..a5c3ea265 100644--- a/backend/internal/services/network_service.go+++ b/backend/internal/services/network_service.go@@ -9,6 +9,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/models"dockerutil "github.com/getarcaneapp/arcane/backend/internal/utils/docker""github.com/getarcaneapp/arcane/backend/internal/utils/pagination"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"networktypes "github.com/getarcaneapp/arcane/types/network""github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/network"@@ -35,7 +36,7 @@ func (s *NetworkService) GetNetworkByID(ctx context.Context, id string) (*networreturn nil, fmt.Errorf("failed to connect to Docker: %w", err)}- networkInspect, err := dockerClient.NetworkInspect(ctx, id, client.NetworkInspectOptions{})+ networkInspect, err := libarcane.NetworkInspectWithCompatibility(ctx, dockerClient, id, client.NetworkInspectOptions{})if err != nil {return nil, fmt.Errorf("network not found: %w", err)}@@ -86,7 +87,7 @@ func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user modereturn fmt.Errorf("failed to connect to Docker: %w", err)}- networkInfo, err := dockerClient.NetworkInspect(ctx, id, client.NetworkInspectOptions{})+ networkInfo, err := libarcane.NetworkInspectWithCompatibility(ctx, dockerClient, id, client.NetworkInspectOptions{})var networkName stringif err == nil {networkName = networkInfo.Network.Namediff --git a/backend/internal/services/system_upgrade_service.go b/backend/internal/services/system_upgrade_service.goindex 4013e28e7..f1372e26c 100644--- a/backend/internal/services/system_upgrade_service.go+++ b/backend/internal/services/system_upgrade_service.go@@ -13,6 +13,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/models"dockerutils "github.com/getarcaneapp/arcane/backend/internal/utils/docker""github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"containertypes "github.com/moby/moby/api/types/container"mounttypes "github.com/moby/moby/api/types/mount""github.com/moby/moby/client"@@ -227,7 +228,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containe}// Try to inspect the container directly- container, err := dockerClient.ContainerInspect(ctx, containerId, client.ContainerInspectOptions{})+ container, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerId, client.ContainerInspectOptions{})if err == nil {return container.Container, nil}@@ -246,7 +247,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containefor _, c := range containers.Items {if strings.HasPrefix(c.ID, containerId) {- inspect, inspectErr := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspect, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})if inspectErr != nil {return containertypes.InspectResponse{}, inspectErr}@@ -262,7 +263,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containefor _, c := range allContainers.Items {if strings.HasPrefix(c.ID, containerId) || c.ID == containerId {- inspect, inspectErr := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspect, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})if inspectErr != nil {return containertypes.InspectResponse{}, inspectErr}diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.goindex 1d06966ee..0973b78bd 100644--- a/backend/internal/services/updater_service.go+++ b/backend/internal/services/updater_service.go@@ -428,7 +428,7 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerIDslog.InfoContext(ctx, "UpdateSingleContainer: found container", "containerID", containerID, "name", containerName, "image", targetContainer.Image)// Inspect container to get full config (needed for label-based controls)- inspectBeforeResult, err := dcli.ContainerInspect(ctx, targetContainer.ID, client.ContainerInspectOptions{})+ inspectBeforeResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dcli, targetContainer.ID, client.ContainerInspectOptions{})if err != nil {out.Items = append(out.Items, updater.ResourceResult{ResourceID: targetContainer.ID,@@ -923,7 +923,7 @@ func (s *UpdaterService) collectUsedImagesFromContainersInternal(ctx context.Concontinue}- inspectResult, err := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})if err != nil {slog.DebugContext(ctx, "collectUsedImagesFromContainersInternal: container inspect failed", "containerId", c.ID, "err", err)continue@@ -1255,7 +1255,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDif len(markedForRestart) > 0 {for i := range containersWithDeps {cwd := containersWithDeps[i]- inspectResult, ierr := dcli.ContainerInspect(ctx, cwd.Container.ID, client.ContainerInspectOptions{})+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, cwd.Container.ID, client.ContainerInspectOptions{})if ierr != nil {continue}@@ -1317,7 +1317,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDname := cd.Namelabels := map[string]string{}if p.inspect == nil {- inspectResult, ierr := dcli.ContainerInspect(ctx, p.cnt.ID, client.ContainerInspectOptions{})+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, p.cnt.ID, client.ContainerInspectOptions{})if ierr != nil {res := updater.ResourceResult{ResourceID: p.cnt.ID,@@ -1614,7 +1614,7 @@ func (s *UpdaterService) anyImageIDsStillInUse(ctx context.Context, ids []string}list := listResult.Itemsfor _, c := range list {- inspectResult, ierr := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})if ierr != nil {continue}@@ -1670,7 +1670,7 @@ func (s *UpdaterService) buildRunningImageIDSetInternal(ctx context.Context) (macontinue}- inspectResult, ierr := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})inspect := inspectResult.Containerif ierr == nil && inspect.Image != "" {inUseSet[inspect.Image] = struct{}{}diff --git a/backend/internal/services/version_service.go b/backend/internal/services/version_service.goindex 0f53572e3..ed0a11cbd 100644--- a/backend/internal/services/version_service.go+++ b/backend/internal/services/version_service.go@@ -15,6 +15,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/utils/arcaneupdater""github.com/getarcaneapp/arcane/backend/internal/utils/cache""github.com/getarcaneapp/arcane/backend/internal/utils/docker"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane""github.com/getarcaneapp/arcane/types/version"containertypes "github.com/moby/moby/api/types/container""github.com/moby/moby/client"@@ -293,7 +294,7 @@ func (s *VersionService) detectCurrentImageInfo(ctx context.Context) (tag string}slog.Debug("detectCurrentImageInfo: detected container", "containerId", containerId)- inspectResult, err := dockerClient.ContainerInspect(ctx, containerId, client.ContainerInspectOptions{})+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerId, client.ContainerInspectOptions{})if err != nil {slog.Debug("detectCurrentImageInfo: failed to inspect container", "containerId", containerId, "error", err)return "", "", ""diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.goindex 5500d7465..5f51fabf5 100644--- a/backend/internal/services/volume_service.go+++ b/backend/internal/services/volume_service.go@@ -404,7 +404,7 @@ func (s *VolumeService) getHelperImageInternal(ctx context.Context, dockerClientfunc (s *VolumeService) resolveArcaneHelperImageInternal(ctx context.Context, dockerClient *client.Client) (string, string, bool) {hostname, _ := os.Hostname()if hostname != "" {- if inspect, err := dockerClient.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {+ if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {return inspect.Container.Config.Image, "hostname", true}}@@ -440,7 +440,7 @@ func (s *VolumeService) resolveBackupStorageMountInternal(ctx context.Context, dif dockerClient != nil {containerID := s.getArcaneContainerIDInternal(ctx, dockerClient)if containerID != "" {- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})if err != nil {slog.WarnContext(ctx, "volume service: failed to inspect arcane container for backup mount resolution, falling back to named volume", "container_id", containerID, "error", err.Error())} else if resolved, ok := resolveBackupStorageMountFromMountsInternal(inspect.Container.Mounts, target, readOnly); ok {@@ -510,7 +510,7 @@ func (s *VolumeService) BackupMountWarning(ctx context.Context) string {return ""}- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})if err != nil {return ""}@@ -521,7 +521,7 @@ func (s *VolumeService) BackupMountWarning(ctx context.Context) string {func (s *VolumeService) getArcaneContainerIDInternal(ctx context.Context, dockerClient *client.Client) string {hostname, _ := os.Hostname()if hostname != "" {- if inspect, err := dockerClient.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{}); err == nil {+ if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil {return inspect.Container.ID}}@@ -737,7 +737,7 @@ func (s *VolumeService) getReusableReadOnlyContainerInternal(ctx context.Contextreturn "", false}- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})if err != nil || inspect.Container.State == nil || !inspect.Container.State.Running {s.helperMu.Lock()delete(s.helperByVolume, volumeName)diff --git a/backend/internal/utils/arcaneupdater/sorter.go b/backend/internal/utils/arcaneupdater/sorter.goindex d61de3174..cb19f34be 100644--- a/backend/internal/utils/arcaneupdater/sorter.go+++ b/backend/internal/utils/arcaneupdater/sorter.go@@ -185,28 +185,34 @@ func UpdateImplicitRestart(containers []ContainerWithDeps, markedForRestart map[}// Check if any dependency is marked for restart- allDeps := make([]string, 0, len(c.Links)+len(c.DependsOn)+len(c.NetworkDeps))- allDeps = append(allDeps, c.Links...)- allDeps = append(allDeps, c.DependsOn...)- allDeps = append(allDeps, c.NetworkDeps...)-- for _, dep := range allDeps {- if markedForRestart[dep] {- // This container's dependency is restarting, so it needs to restart too- markedForRestart[c.Name] = true- if containers[i].Container.Labels == nil {- containers[i].Container.Labels = map[string]string{}- }- containers[i].Container.Labels["_arcane_implicit_restart"] = "true"- implicitRestarts = append(implicitRestarts, c.Name)- break- }+ if !hasMarkedDependencyInternal(markedForRestart, c.Links) &&+ !hasMarkedDependencyInternal(markedForRestart, c.DependsOn) &&+ !hasMarkedDependencyInternal(markedForRestart, c.NetworkDeps) {+ continue}++ // This container's dependency is restarting, so it needs to restart too+ markedForRestart[c.Name] = true+ if containers[i].Container.Labels == nil {+ containers[i].Container.Labels = map[string]string{}+ }+ containers[i].Container.Labels["_arcane_implicit_restart"] = "true"+ implicitRestarts = append(implicitRestarts, c.Name)}return implicitRestarts}+func hasMarkedDependencyInternal(markedForRestart map[string]bool, deps []string) bool {+ for _, dep := range deps {+ if markedForRestart[dep] {+ return true+ }+ }++ return false+}+// ExtractContainerName extracts a clean container name from the summaryfunc ExtractContainerName(cnt container.Summary) string {if len(cnt.Names) > 0 {diff --git a/backend/internal/utils/docker/mount_utils.go b/backend/internal/utils/docker/mount_utils.goindex 1e5a5aedd..8aecda7c4 100644--- a/backend/internal/utils/docker/mount_utils.go+++ b/backend/internal/utils/docker/mount_utils.go@@ -6,6 +6,7 @@ import ("strings""github.com/getarcaneapp/arcane/backend/internal/utils/pathmapper"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"containertypes "github.com/moby/moby/api/types/container"mounttypes "github.com/moby/moby/api/types/mount""github.com/moby/moby/client"@@ -26,7 +27,7 @@ func GetHostPathForContainerPath(ctx context.Context, dockerCli *client.Client,}// 2. Inspect self- inspect, err := dockerCli.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{})+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerCli, hostname, client.ContainerInspectOptions{})if err != nil {// Not running in a container or can't reach docker daemonreturn "", errdiff --git a/backend/pkg/libarcane/inspect_compat.go b/backend/pkg/libarcane/inspect_compat.gonew file mode 100644index 000000000..6eb64252e--- /dev/null+++ b/backend/pkg/libarcane/inspect_compat.go@@ -0,0 +1,460 @@+package libarcane++import (+ "bufio"+ "context"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/netip"+ "net/url"+ "path"+ "strconv"+ "strings"++ containertypes "github.com/moby/moby/api/types/container"+ networktypes "github.com/moby/moby/api/types/network"+ "github.com/moby/moby/client"+)++// WrapDockerAPIClientForInspectCompatibility wraps a Docker API client so+// inspect calls can recover from daemon responses that encode address fields+// with CIDR suffixes that newer typed Moby structs reject.+func WrapDockerAPIClientForInspectCompatibility(apiClient client.APIClient) client.APIClient {+ if apiClient == nil {+ return nil+ }+ if _, ok := apiClient.(*inspectCompatibilityClient); ok {+ return apiClient+ }+ return &inspectCompatibilityClient{APIClient: apiClient}+}++type inspectCompatibilityClient struct {+ client.APIClient+}++func (c *inspectCompatibilityClient) ContainerInspect(ctx context.Context, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {+ return ContainerInspectWithCompatibility(ctx, c.APIClient, containerID, options)+}++func (c *inspectCompatibilityClient) NetworkInspect(ctx context.Context, networkID string, options client.NetworkInspectOptions) (client.NetworkInspectResult, error) {+ return NetworkInspectWithCompatibility(ctx, c.APIClient, networkID, options)+}++// ContainerInspectWithCompatibility retries inspect decoding against raw daemon+// JSON when the primary typed decode fails on a ParseAddr-style CIDR issue.+func ContainerInspectWithCompatibility(ctx context.Context, apiClient client.APIClient, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {+ if apiClient == nil {+ return client.ContainerInspectResult{}, fmt.Errorf("docker api client is nil")+ }++ result, err := apiClient.ContainerInspect(ctx, containerID, options)+ if err == nil || !isInspectAddressParseErrorInternal(err) {+ return result, err+ }++ query := url.Values{}+ if options.Size {+ query.Set("size", "1")+ }++ raw, fetchErr := fetchDockerAPIJSONInternal(ctx, apiClient, "/containers/"+strings.TrimSpace(containerID)+"/json", query)+ if fetchErr != nil {+ return client.ContainerInspectResult{}, err+ }++ normalized, changed, normalizeContainerInspectRawJSONInternalErr := normalizeContainerInspectRawJSONInternal(raw)+ if normalizeContainerInspectRawJSONInternalErr != nil || !changed {+ return client.ContainerInspectResult{}, err+ }++ var repaired containertypes.InspectResponse+ if unmarshalErr := json.Unmarshal(normalized, &repaired); unmarshalErr != nil {+ return client.ContainerInspectResult{}, err+ }++ return client.ContainerInspectResult{+ Container: repaired,+ Raw: normalized,+ }, nil+}++// NetworkInspectWithCompatibility retries inspect decoding against raw daemon+// JSON when the primary typed decode fails on a ParseAddr-style CIDR issue.+func NetworkInspectWithCompatibility(ctx context.Context, apiClient client.APIClient, networkID string, options client.NetworkInspectOptions) (client.NetworkInspectResult, error) {+ if apiClient == nil {+ return client.NetworkInspectResult{}, fmt.Errorf("docker api client is nil")+ }++ result, err := apiClient.NetworkInspect(ctx, networkID, options)+ if err == nil || !isInspectAddressParseErrorInternal(err) {+ return result, err+ }++ query := url.Values{}+ if options.Verbose {+ query.Set("verbose", "true")+ }+ if scope := strings.TrimSpace(options.Scope); scope != "" {+ query.Set("scope", scope)+ }++ raw, fetchErr := fetchDockerAPIJSONInternal(ctx, apiClient, "/networks/"+strings.TrimSpace(networkID), query)+ if fetchErr != nil {+ return client.NetworkInspectResult{}, err+ }++ normalized, changed, normalizeNetworkInspectRawJSONInternalErr := normalizeNetworkInspectRawJSONInternal(raw)+ if normalizeNetworkInspectRawJSONInternalErr != nil || !changed {+ return client.NetworkInspectResult{}, err+ }++ var repaired networktypes.Inspect+ if unmarshalErr := json.Unmarshal(normalized, &repaired); unmarshalErr != nil {+ return client.NetworkInspectResult{}, err+ }++ return client.NetworkInspectResult{+ Network: repaired,+ Raw: normalized,+ }, nil+}++func fetchDockerAPIJSONInternal(ctx context.Context, apiClient client.APIClient, resourcePath string, query url.Values) ([]byte, error) {+ dialer := apiClient.Dialer()+ if dialer == nil {+ return nil, fmt.Errorf("docker api client does not expose a dialer")+ }++ reqURL := &url.URL{+ Scheme: "http",+ Host: client.DummyHost,+ Path: buildDockerAPIPathInternal(apiClient.ClientVersion(), resourcePath),+ RawQuery: query.Encode(),+ }+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL.String(), http.NoBody)+ if err != nil {+ return nil, err+ }++ // The official Moby client uses a TLS-aware dialer here when the daemon is+ // configured with client certificates, so this fallback continues to work+ // for remote tcp+TLS and local socket transports without reimplementing the+ // client's private request machinery.+ conn, err := dialer(ctx)+ if err != nil {+ return nil, err+ }+ defer func() { _ = conn.Close() }()++ if err := req.Write(conn); err != nil {+ return nil, err+ }++ resp, err := http.ReadResponse(bufio.NewReader(conn), req)+ if err != nil {+ return nil, err+ }+ defer func() { _ = resp.Body.Close() }()++ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return nil, err+ }+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return nil, fmt.Errorf("docker api GET %s failed with %s: %s", resourcePath, resp.Status, strings.TrimSpace(string(body)))+ }++ return body, nil+}++func buildDockerAPIPathInternal(version, resourcePath string) string {+ if trimmedVersion := strings.TrimSpace(strings.TrimPrefix(version, "v")); trimmedVersion != "" {+ return path.Join("/v"+trimmedVersion, resourcePath)+ }+ return path.Join("/", resourcePath)+}++func normalizeContainerInspectRawJSONInternal(raw []byte) ([]byte, bool, error) {+ payload := map[string]any{}+ if err := json.Unmarshal(raw, &payload); err != nil {+ return nil, false, err+ }++ changed := false++ networkSettings, ok := asMapInternal(payload["NetworkSettings"])+ if ok {+ changed = normalizeAddressStringFieldInternal(networkSettings, "Gateway") || changed+ changed = normalizeAddressStringFieldInternal(networkSettings, "IPv6Gateway") || changed+ changed = normalizeAddressWithPrefixFieldInternal(networkSettings, "IPAddress", "IPPrefixLen") || changed+ changed = normalizeAddressWithPrefixFieldInternal(networkSettings, "GlobalIPv6Address", "GlobalIPv6PrefixLen") || changed++ if networks, ok := asMapInternal(networkSettings["Networks"]); ok {+ for _, endpointAny := range networks {+ endpoint, ok := asMapInternal(endpointAny)+ if !ok {+ continue+ }++ changed = normalizeAddressStringFieldInternal(endpoint, "Gateway") || changed+ changed = normalizeAddressStringFieldInternal(endpoint, "IPv6Gateway") || changed+ changed = normalizeAddressWithPrefixFieldInternal(endpoint, "IPAddress", "IPPrefixLen") || changed+ changed = normalizeAddressWithPrefixFieldInternal(endpoint, "GlobalIPv6Address", "GlobalIPv6PrefixLen") || changed++ if ipam, ok := asMapInternal(endpoint["IPAMConfig"]); ok {+ changed = normalizeAddressStringFieldInternal(ipam, "IPv4Address") || changed+ changed = normalizeAddressStringFieldInternal(ipam, "IPv6Address") || changed+ changed = normalizeAddressStringSliceFieldInternal(ipam, "LinkLocalIPs") || changed+ }+ }+ }+ }++ if !changed {+ return raw, false, nil+ }++ normalized, err := json.Marshal(payload)+ if err != nil {+ return nil, false, err+ }+ return normalized, true, nil+}++func normalizeNetworkInspectRawJSONInternal(raw []byte) ([]byte, bool, error) {+ payload := map[string]any{}+ if err := json.Unmarshal(raw, &payload); err != nil {+ return nil, false, err+ }++ changed := false+ if ipam, ok := asMapInternal(payload["IPAM"]); ok {+ if configs, ok := asSliceInternal(ipam["Config"]); ok {+ for _, configAny := range configs {+ config, ok := asMapInternal(configAny)+ if !ok {+ continue+ }++ changed = normalizeAddressStringFieldInternal(config, "Gateway") || changed+ changed = normalizeAuxiliaryAddressesInternal(config, "AuxiliaryAddresses") || changed+ changed = normalizeAuxiliaryAddressesInternal(config, "AuxAddress") || changed+ }+ }+ }+ if containers, ok := asMapInternal(payload["Containers"]); ok {+ for _, endpointAny := range containers {+ endpoint, ok := asMapInternal(endpointAny)+ if !ok {+ continue+ }++ changed = normalizePrefixStringFieldInternal(endpoint, "IPv4Address") || changed+ changed = normalizePrefixStringFieldInternal(endpoint, "IPv6Address") || changed+ }+ }++ if !changed {+ return raw, false, nil+ }++ normalized, err := json.Marshal(payload)+ if err != nil {+ return nil, false, err+ }+ return normalized, true, nil+}++func normalizeAddressStringFieldInternal(obj map[string]any, key string) bool {+ raw, ok := obj[key].(string)+ if !ok {+ return false+ }++ normalized, changed := normalizeAddressStringInternal(raw)+ if !changed {+ return false+ }++ obj[key] = normalized+ return true+}++func normalizeAddressWithPrefixFieldInternal(obj map[string]any, addrKey, prefixLenKey string) bool {+ raw, ok := obj[addrKey].(string)+ if !ok {+ return false+ }++ trimmed := strings.TrimSpace(raw)+ if trimmed == "" {+ return false+ }+ if _, err := netip.ParseAddr(trimmed); err == nil {+ if raw == trimmed {+ return false+ }+ obj[addrKey] = trimmed+ return true+ }++ prefix, err := netip.ParsePrefix(trimmed)+ if err != nil {+ return false+ }++ changed := false+ addrValue := prefix.Addr().String()+ if raw != addrValue {+ obj[addrKey] = addrValue+ changed = true+ }++ if prefixLenMissingInternal(obj[prefixLenKey]) {+ obj[prefixLenKey] = prefix.Bits()+ changed = true+ }++ return changed+}++func normalizeAddressStringSliceFieldInternal(obj map[string]any, key string) bool {+ values, ok := asSliceInternal(obj[key])+ if !ok {+ return false+ }++ changed := false+ for i, value := range values {+ raw, ok := value.(string)+ if !ok {+ continue+ }+ normalized, fieldChanged := normalizeAddressStringInternal(raw)+ if !fieldChanged {+ continue+ }+ values[i] = normalized+ changed = true+ }++ if changed {+ obj[key] = values+ }+ return changed+}++func normalizeAuxiliaryAddressesInternal(obj map[string]any, key string) bool {+ auxMap, ok := asMapInternal(obj[key])+ if !ok {+ return false+ }++ changed := false+ for auxKey, auxValue := range auxMap {+ raw, ok := auxValue.(string)+ if !ok {+ continue+ }+ normalized, fieldChanged := normalizeAddressStringInternal(raw)+ if !fieldChanged {+ continue+ }+ auxMap[auxKey] = normalized+ changed = true+ }++ if changed {+ obj[key] = auxMap+ }+ return changed+}++func normalizePrefixStringFieldInternal(obj map[string]any, key string) bool {+ raw, ok := obj[key].(string)+ if !ok {+ return false+ }++ trimmed := strings.TrimSpace(raw)+ if trimmed == "" {+ return false+ }++ prefix, err := netip.ParsePrefix(trimmed)+ if err != nil {+ return false+ }++ normalized := prefix.String()+ if normalized == raw {+ return false+ }++ obj[key] = normalized+ return true+}++func normalizeAddressStringInternal(raw string) (string, bool) {+ trimmed := strings.TrimSpace(raw)+ if trimmed == "" {+ return raw, false+ }+ if _, err := netip.ParseAddr(trimmed); err == nil {+ return trimmed, trimmed != raw+ }++ prefix, err := netip.ParsePrefix(trimmed)+ if err != nil {+ return raw, false+ }++ normalized := prefix.Addr().String()+ return normalized, normalized != raw+}++func prefixLenMissingInternal(value any) bool {+ switch v := value.(type) {+ case nil:+ return true+ case float64:+ return v == 0+ case int:+ return v == 0+ case int32:+ return v == 0+ case int64:+ return v == 0+ case string:+ trimmed := strings.TrimSpace(v)+ if trimmed == "" {+ return true+ }+ parsed, err := strconv.Atoi(trimmed)+ return err != nil || parsed == 0+ default:+ return false+ }+}++func asMapInternal(value any) (map[string]any, bool) {+ out, ok := value.(map[string]any)+ return out, ok+}++func asSliceInternal(value any) ([]any, bool) {+ out, ok := value.([]any)+ return out, ok+}++func isInspectAddressParseErrorInternal(err error) bool {+ if err == nil {+ return false+ }++ msg := err.Error()+ return strings.Contains(msg, "ParseAddr(") || strings.Contains(msg, "ParsePrefix(")+}diff --git a/backend/pkg/libarcane/inspect_compat_test.go b/backend/pkg/libarcane/inspect_compat_test.gonew file mode 100644index 000000000..ac781e0e5--- /dev/null+++ b/backend/pkg/libarcane/inspect_compat_test.go@@ -0,0 +1,340 @@+package libarcane++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "net/netip"+ "strings"+ "testing"++ containertypes "github.com/moby/moby/api/types/container"+ networktypes "github.com/moby/moby/api/types/network"+ "github.com/moby/moby/client"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestNormalizeContainerInspectRawJSONInternal(t *testing.T) {+ raw := []byte(`{+ "Id":"abc123",+ "Name":"/app",+ "Config":{"Image":"test:latest"},+ "HostConfig":{"NetworkMode":"bridge"},+ "NetworkSettings":{+ "Networks":{+ "bridge":{+ "IPAMConfig":{+ "IPv4Address":"172.18.0.50/16",+ "IPv6Address":"fdd0:0:0:c::10/64",+ "LinkLocalIPs":["169.254.10.10/16","fe80::10/64"]+ },+ "Gateway":"172.18.0.1/16",+ "IPAddress":"172.18.0.20/16",+ "IPPrefixLen":0,+ "IPv6Gateway":"fdd0:0:0:c::1/64",+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",+ "GlobalIPv6PrefixLen":0+ }+ }+ }+ }`)++ normalized, changed, err := normalizeContainerInspectRawJSONInternal(raw)+ require.NoError(t, err)+ require.True(t, changed)++ var inspect containertypes.InspectResponse+ require.NoError(t, json.Unmarshal(normalized, &inspect))++ endpoint := inspect.NetworkSettings.Networks["bridge"]+ require.NotNil(t, endpoint)+ require.NotNil(t, endpoint.IPAMConfig)+ assert.Equal(t, netip.MustParseAddr("172.18.0.1"), endpoint.Gateway)+ assert.Equal(t, netip.MustParseAddr("172.18.0.20"), endpoint.IPAddress)+ assert.Equal(t, 16, endpoint.IPPrefixLen)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), endpoint.IPv6Gateway)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.GlobalIPv6Address)+ assert.Equal(t, 64, endpoint.GlobalIPv6PrefixLen)+ assert.Equal(t, netip.MustParseAddr("172.18.0.50"), endpoint.IPAMConfig.IPv4Address)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.IPAMConfig.IPv6Address)+ assert.Equal(t, []netip.Addr{+ netip.MustParseAddr("169.254.10.10"),+ netip.MustParseAddr("fe80::10"),+ }, endpoint.IPAMConfig.LinkLocalIPs)+}++func TestNormalizeContainerInspectRawJSONInternal_NormalizesTopLevelNetworkSettings(t *testing.T) {+ raw := []byte(`{+ "Id":"abc123",+ "Name":"/app",+ "Config":{"Image":"test:latest"},+ "HostConfig":{"NetworkMode":"bridge"},+ "NetworkSettings":{+ "Gateway":"172.18.0.1/16",+ "IPAddress":"172.18.0.20/16",+ "IPPrefixLen":0,+ "IPv6Gateway":"fdd0:0:0:c::1/64",+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",+ "GlobalIPv6PrefixLen":0,+ "Networks":{}+ }+ }`)++ normalized, changed, err := normalizeContainerInspectRawJSONInternal(raw)+ require.NoError(t, err)+ require.True(t, changed)++ payload := map[string]any{}+ require.NoError(t, json.Unmarshal(normalized, &payload))++ networkSettings, ok := asMapInternal(payload["NetworkSettings"])+ require.True(t, ok)+ assert.Equal(t, "172.18.0.1", networkSettings["Gateway"])+ assert.Equal(t, "172.18.0.20", networkSettings["IPAddress"])+ assert.Equal(t, float64(16), networkSettings["IPPrefixLen"])+ assert.Equal(t, "fdd0:0:0:c::1", networkSettings["IPv6Gateway"])+ assert.Equal(t, "fdd0:0:0:c::10", networkSettings["GlobalIPv6Address"])+ assert.Equal(t, float64(64), networkSettings["GlobalIPv6PrefixLen"])+}++func TestNormalizeNetworkInspectRawJSONInternal(t *testing.T) {+ raw := []byte(`{+ "Name":"test-net",+ "Id":"net123",+ "Created":"2026-03-11T00:00:00Z",+ "Scope":"local",+ "Driver":"bridge",+ "EnableIPv6":true,+ "IPAM":{+ "Driver":"default",+ "Config":[+ {+ "Subnet":"fdd0:0:0:c::/64",+ "Gateway":"fdd0:0:0:c::1/64",+ "AuxiliaryAddresses":{+ "router":"fdd0:0:0:c::2/64"+ }+ }+ ]+ },+ "Containers":{}+ }`)++ normalized, changed, err := normalizeNetworkInspectRawJSONInternal(raw)+ require.NoError(t, err)+ require.True(t, changed)++ var inspect networktypes.Inspect+ require.NoError(t, json.Unmarshal(normalized, &inspect))+ require.Len(t, inspect.IPAM.Config, 1)+ assert.Equal(t, netip.MustParsePrefix("fdd0:0:0:c::/64"), inspect.IPAM.Config[0].Subnet)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), inspect.IPAM.Config[0].Gateway)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::2"), inspect.IPAM.Config[0].AuxAddress["router"])+}++func TestNormalizeNetworkInspectRawJSONInternal_NormalizesContainerEndpoints(t *testing.T) {+ raw := []byte(`{+ "Name":"test-net",+ "Id":"net123",+ "Created":"2026-03-11T00:00:00Z",+ "Scope":"local",+ "Driver":"bridge",+ "IPAM":{"Driver":"default","Config":[]},+ "Containers":{+ "abc123":{+ "Name":"app",+ "EndpointID":"ep1",+ "IPv4Address":" 172.18.0.20/16 ",+ "IPv6Address":" fdd0:0:0:c::10/64 "+ }+ }+ }`)++ normalized, changed, err := normalizeNetworkInspectRawJSONInternal(raw)+ require.NoError(t, err)+ require.True(t, changed)++ var inspect networktypes.Inspect+ require.NoError(t, json.Unmarshal(normalized, &inspect))+ endpoint := inspect.Containers["abc123"]+ assert.Equal(t, netip.MustParsePrefix("172.18.0.20/16"), endpoint.IPv4Address)+ assert.Equal(t, netip.MustParsePrefix("fdd0:0:0:c::10/64"), endpoint.IPv6Address)+}++func TestNormalizeAddressStringInternal_TrimsWhitespaceAroundValidAddress(t *testing.T) {+ normalized, changed := normalizeAddressStringInternal(" 172.18.0.1 ")+ assert.True(t, changed)+ assert.Equal(t, "172.18.0.1", normalized)+}++func TestNormalizeAddressWithPrefixFieldInternal_TrimsWhitespaceAroundValidAddress(t *testing.T) {+ obj := map[string]any{+ "IPAddress": " 172.18.0.20 ",+ "IPPrefixLen": 24,+ }++ changed := normalizeAddressWithPrefixFieldInternal(obj, "IPAddress", "IPPrefixLen")+ assert.True(t, changed)+ assert.Equal(t, "172.18.0.20", obj["IPAddress"])+ assert.Equal(t, 24, obj["IPPrefixLen"])+}++func TestIsInspectAddressParseErrorInternal_MatchesPrefixErrors(t *testing.T) {+ _, err := netip.ParsePrefix(" 172.18.0.20/16 ")+ assert.True(t, isInspectAddressParseErrorInternal(err))+}++func TestContainerInspectWithCompatibility(t *testing.T) {+ containerJSON := `{+ "Id":"abc123",+ "Name":"/app",+ "Config":{"Image":"test:latest"},+ "HostConfig":{"NetworkMode":"bridge"},+ "NetworkSettings":{+ "Networks":{+ "bridge":{+ "IPAMConfig":{"IPv6Address":"fdd0:0:0:c::10/64"},+ "IPv6Gateway":"fdd0:0:0:c::1/64",+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",+ "GlobalIPv6PrefixLen":0+ }+ }+ }+ }`++ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {+ assert.Equal(t, "/v1.41/containers/test-container/json", r.URL.Path)+ _, _ = w.Write([]byte(containerJSON))+ })++ result, err := ContainerInspectWithCompatibility(context.Background(), dockerClient, "test-container", client.ContainerInspectOptions{})+ require.NoError(t, err)+ assert.Equal(t, "abc123", result.Container.ID)+ endpoint := result.Container.NetworkSettings.Networks["bridge"]+ require.NotNil(t, endpoint)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), endpoint.IPv6Gateway)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.GlobalIPv6Address)+ assert.Equal(t, 64, endpoint.GlobalIPv6PrefixLen)+}++func TestNetworkInspectWithCompatibility(t *testing.T) {+ networkJSON := `{+ "Name":"test-net",+ "Id":"net123",+ "Created":"2026-03-11T00:00:00Z",+ "Scope":"local",+ "Driver":"bridge",+ "IPAM":{+ "Driver":"default",+ "Config":[+ {+ "Subnet":"fdd0:0:0:c::/64",+ "Gateway":"fdd0:0:0:c::1/64"+ }+ ]+ },+ "Containers":{}+ }`++ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {+ assert.Equal(t, "/v1.41/networks/test-net", r.URL.Path)+ _, _ = w.Write([]byte(networkJSON))+ })++ result, err := NetworkInspectWithCompatibility(context.Background(), dockerClient, "test-net", client.NetworkInspectOptions{})+ require.NoError(t, err)+ require.Len(t, result.Network.IPAM.Config, 1)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Network.IPAM.Config[0].Gateway)+}++func TestContainerInspectWithCompatibility_TLSRemote(t *testing.T) {+ containerJSON := `{+ "Id":"abc123",+ "Name":"/app",+ "Config":{"Image":"test:latest"},+ "HostConfig":{"NetworkMode":"bridge"},+ "NetworkSettings":{+ "Networks":{+ "bridge":{+ "IPv6Gateway":"fdd0:0:0:c::1/64"+ }+ }+ }+ }`++ server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ assert.Equal(t, "/v1.41/containers/test-container/json", r.URL.Path)+ _, _ = w.Write([]byte(containerJSON))+ }))+ defer server.Close()++ dockerClient, err := client.New(+ client.WithHTTPClient(server.Client()),+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "https://")),+ client.WithScheme("https"),+ client.WithAPIVersion("1.41"),+ )+ require.NoError(t, err)+ defer func() {+ _ = dockerClient.Close()+ }()++ result, err := ContainerInspectWithCompatibility(context.Background(), dockerClient, "test-container", client.ContainerInspectOptions{})+ require.NoError(t, err)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Container.NetworkSettings.Networks["bridge"].IPv6Gateway)+}++func TestInspectCompatibilityLeavesInvalidValuesFailing(t *testing.T) {+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {+ _, _ = w.Write([]byte(`{+ "Name":"test-net",+ "Id":"net123",+ "Created":"2026-03-11T00:00:00Z",+ "Scope":"local",+ "Driver":"bridge",+ "IPAM":{"Driver":"default","Config":[{"Subnet":"fdd0:0:0:c::/64","Gateway":"definitely-not-an-ip"}]},+ "Containers":{}+ }`))+ })++ _, err := NetworkInspectWithCompatibility(context.Background(), dockerClient, "test-net", client.NetworkInspectOptions{})+ require.Error(t, err)+ assert.True(t, strings.Contains(err.Error(), `ParseAddr("definitely-not-an-ip")`))+}++func TestWrapDockerAPIClientForInspectCompatibility(t *testing.T) {+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {+ _, _ = w.Write([]byte(`{+ "Id":"abc123",+ "Name":"/app",+ "Config":{"Image":"test:latest"},+ "HostConfig":{"NetworkMode":"bridge"},+ "NetworkSettings":{"Networks":{"bridge":{"IPv6Gateway":"fdd0:0:0:c::1/64"}}}+ }`))+ })++ wrapped := WrapDockerAPIClientForInspectCompatibility(dockerClient)+ result, err := wrapped.ContainerInspect(context.Background(), "test-container", client.ContainerInspectOptions{})+ require.NoError(t, err)+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Container.NetworkSettings.Networks["bridge"].IPv6Gateway)+}++func newTestDockerClient(t *testing.T, handler http.HandlerFunc) *client.Client {+ t.Helper()++ server := httptest.NewServer(handler)+ t.Cleanup(server.Close)++ dockerClient, err := client.New(+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "http://")),+ client.WithAPIVersion("1.41"),+ )+ require.NoError(t, err)+ t.Cleanup(func() {+ _ = dockerClient.Close()+ })++ return dockerClient+}diff --git a/backend/pkg/projects/compose.go b/backend/pkg/projects/compose.goindex af1ecff06..2c915d7f1 100644--- a/backend/pkg/projects/compose.go+++ b/backend/pkg/projects/compose.go@@ -9,6 +9,8 @@ import ("github.com/docker/cli/cli/flags""github.com/docker/compose/v5/pkg/api"composev2 "github.com/docker/compose/v5/pkg/compose"+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"+ "github.com/moby/moby/client")type Client struct {@@ -25,14 +27,36 @@ func NewClient(ctx context.Context) (*Client, error) {if err := cli.Initialize(opts); err != nil {return nil, err}- svc, err := composev2.NewComposeService(cli,++ composeCLI := wrapDockerCLIWithInspectCompatibilityInternal(cli)+ svc, err := composev2.NewComposeService(composeCLI,composev2.WithPrompt(composev2.AlwaysOkPrompt()),)if err != nil {return nil, err}- return &Client{svc: svc, dockerCli: cli}, nil+ return &Client{svc: svc, dockerCli: composeCLI}, nil+}++type inspectCompatibleDockerCli struct {+ command.Cli+ apiClient client.APIClient+}++func (c *inspectCompatibleDockerCli) Client() client.APIClient {+ return c.apiClient+}++func wrapDockerCLIWithInspectCompatibilityInternal(cli command.Cli) command.Cli {+ if cli == nil {+ return nil+ }++ return &inspectCompatibleDockerCli{+ Cli: cli,+ apiClient: libarcane.WrapDockerAPIClientForInspectCompatibility(cli.Client()),+ }}func (c *Client) Close() error {diff --git a/backend/pkg/projects/compose_test.go b/backend/pkg/projects/compose_test.gonew file mode 100644index 000000000..09a860f80--- /dev/null+++ b/backend/pkg/projects/compose_test.go@@ -0,0 +1,30 @@+package projects++import (+ "reflect"+ "testing"++ "github.com/docker/cli/cli/command"+ "github.com/docker/cli/cli/flags"+ mobyclient "github.com/moby/moby/client"+ "github.com/stretchr/testify/require"+)++func TestWrapDockerCLIWithInspectCompatibility(t *testing.T) {+ t.Setenv("DOCKER_HOST", "tcp://example.com:2375")++ apiClient, err := mobyclient.New(mobyclient.WithHost("tcp://example.com:2375"))+ require.NoError(t, err)+ t.Cleanup(func() {+ _ = apiClient.Close()+ })++ baseCLI, err := command.NewDockerCli(command.WithAPIClient(apiClient))+ require.NoError(t, err)+ require.NoError(t, baseCLI.Initialize(flags.NewClientOptions()))++ wrapped := wrapDockerCLIWithInspectCompatibilityInternal(baseCLI)+ require.NotNil(t, wrapped)+ require.NotSame(t, baseCLI, wrapped)+ require.NotEqual(t, reflect.TypeOf(apiClient), reflect.TypeOf(wrapped.Client()))+}diff --git a/backend/pkg/scheduler/auto_heal_job.go b/backend/pkg/scheduler/auto_heal_job.goindex f2f399f32..05433384c 100644--- a/backend/pkg/scheduler/auto_heal_job.go+++ b/backend/pkg/scheduler/auto_heal_job.go@@ -105,7 +105,7 @@ func (j *AutoHealJob) Run(ctx context.Context) {}// Inspect to get health status- inspect, err := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})if err != nil {slog.WarnContext(ctx, "auto-heal failed to inspect container", "container", containerName, "error", err)continue