Fix invalid path error when using OCI artifacts on Windows

[mikesir87]

Resolves #13572

And AI disclaimer - Claude performed the troubleshooting and fix in this PR.

I have built the Compose binary locally and validated the fix does work on my Windows machine.

Problem

When using Docker Compose with an OCI artifact on Windows (e.g., docker compose -f oci://dockersamples/welcome-to-docker up), the following error occurred:

CreateFile C:\Users\username\oci:\dockersamples\.env: The filename, directory name, or volume label syntax is incorrect.                                                                                           

This error was introduced between v5.0.0 and v5.0.1, specifically by commit 6c04392 which fixed error handling in setEnvWithDotEnv. The bug existed in v5.0.0 but was silently ignored due to improper error
handling.

Root Cause

The issue occurred in the setEnvWithDotEnv function in cmd/compose/compose.go:

1. When setEnvWithDotEnv is called with an OCI artifact path, it creates ProjectOptions without registering any remote loaders
2. The compose-go library's GetWorkingDir() method doesn't recognize the path as a remote resource
3. It tries to treat the OCI reference as a local file path by calling filepath.Abs() on it
4. On Windows, filepath.Abs("oci://dockersamples/...") produces an invalid path like C:\Users\username\oci:\dockersamples
5. When trying to load .env files, it appends to this malformed path, resulting in: C:\Users\username\oci:\dockersamples\.env
6. Windows rejects this path because colons are only valid after drive letters

Code Flow

In compose-go's cli/options.go, the GetWorkingDir() method:

func (o *ProjectOptions) GetWorkingDir() (string, error) {                                                                                                                                                         
    if o.WorkingDir != "" {                                                                                                                                                                                        
        return filepath.Abs(o.WorkingDir)                                                                                                                                                                          
    }                                                                                                                                                                                                              
PATH:                                                                                                                                                                                                              
    for _, path := range o.ConfigPaths {                                                                                                                                                                           
        if path != "-" {                                                                                                                                                                                           
            for _, l := range o.ResourceLoaders {                                                                                                                                                                  
                if l.Accept(path) {                                                                                                                                                                                
                    break PATH  // Skip filepath.Abs for remote resources                                                                                                                                          
                }                                                                                                                                                                                                  
            }                                                                                                                                                                                                      
            absPath, err := filepath.Abs(path)  // BUG: Called for OCI paths when no loaders registered                                                                                                            
            if err != nil {                                                                                                                                                                                        
                return "", err                                                                                                                                                                                     
            }                                                                                                                                                                                                      
            return filepath.Dir(absPath), nil                                                                                                                                                                      
        }                                                                                                                                                                                                          
    }                                                                                                                                                                                                              
    return os.Getwd()                                                                                                                                                                                              
}                                                                                                                                                                                                                  

Without remote loaders registered, OCI paths fall through to filepath.Abs(), causing the issue.

Solution

Modified setEnvWithDotEnv to detect remote config paths and skip environment loading for them:

func setEnvWithDotEnv(opts ProjectOptions) error {                                                                                                                                                                 
    // Check if we're using a remote config (OCI or Git)                                                                                                                                                           
    // If so, skip env loading as remote loaders haven't been initialized yet                                                                                                                                      
    for _, path := range opts.ConfigPaths {                                                                                                                                                                        
        if strings.HasPrefix(path, remote.OciPrefix) || strings.Contains(path, "://") {                                                                                                                            
            return nil                                                                                                                                                                                             
        }                                                                                                                                                                                                          
    }                                                                                                                                                                                                              
    // ... rest of the function unchanged                                                                                                                                                                          
}                                                                                                                                                                                                                  

This approach:

• Detects remote config paths early (OCI: oci://, Git: URLs with ://)
• Skips the problematic .env loading for remote configs
• Allows normal processing for local compose files
• Environment loading for remote configs happens later in the flow when remote loaders are properly initialized

Testing

• Added tests in cmd/compose/compose_oci_test.go for OCI artifacts, Git remotes, and local paths
  • Verified fix works on Windows ARM64
  • All existing tests pass

Files Changed

• cmd/compose/compose.go: Modified setEnvWithDotEnv function
• cmd/compose/compose_oci_test.go: Added tests for the fix"

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[thaJeztah]

⚠️ canned reply ahead ⚠️

Thank you for contributing! It appears your commit message is missing a DCO sign-off,
causing the DCO check to fail.

We require all commit messages to have a Signed-off-by line with your name
and e-mail (see "Sign your work"
in the CONTRIBUTING.md in this repository), which looks something like:

Signed-off-by: YourFirsName YourLastName <yourname@example.org>

There is no need to open a new pull request, but to fix this (and make CI pass),
you need to amend the commit(s) in this pull request, and "force push" the amended
commit.

Unfortunately, it's not possible to do so through GitHub's web UI, so this needs
to be done through the git commandline.

You can find some instructions in the output of the DCO check (which can be found
in the "checks" tab on this pull request), as well as in the Moby contributing guide.

Steps to do so "roughly" come down to:

1. Set your name and e-mail in git's configuration:

   git config --global user.name "YourFirstName YourLastName"
   git config --global user.email "yourname@example.org"

   (Make sure to use your real name (not your GitHub username/handle) and e-mail)

2. Clone your fork locally

3. Check out the branch associated with this pull request

4. Sign-off and amend the existing commit(s)

   git commit --amend --no-edit --signoff

   If your pull request contains multiple commits, either squash the commits (if
   needed) or sign-off each individual commit.

5. Force push your branch to GitHub (using the --force or --force-with-lease flags) to update the pull request.

Sorry for the hassle (I wish GitHub would make this a bit easier to do), and let me know if you need help or more detailed instructions!