Merge pull request #11400 from glours/fix-fsutils-windows

use a custom version of fsutils that fixes a bug on Windows causing all Compose builds to fail

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ on:
         default: "false"
 
 env:
-  DOCKER_CLI_VERSION: "20.10.17"
+  DOCKER_CLI_VERSION: "25.0.0"
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -138,7 +138,6 @@ jobs:
         mode:
           - plugin
           - standalone
-          - cucumber
     steps:
       -
         name: Checkout
@@ -198,11 +197,6 @@ jobs:
           rm -f /usr/local/bin/docker-compose
           cp bin/build/docker-compose /usr/local/bin
           make e2e-compose-standalone
-      -
-        name: Run cucumber tests
-        if: ${{ matrix.mode == 'cucumber'}}
-        run: |
-          make test-cucumber
 
   coverage:
     runs-on: ubuntu-22.04

.github/workflows/codeql.yml

@@ -0,0 +1,58 @@
+name: codeql
+
+on:
+  push:
+    branches:
+       - 'main'
+    paths-ignore:
+      - '**/*.md'
+      - '**/*.txt'
+      - '**/*.yaml'
+      - '**/*_test.go'
+  pull_request:
+    branches:
+        - 'main'
+    paths-ignore:
+      - '**/*.md'
+      - '**/*.txt'
+      - '**/*.yaml'
+      - '**/*_test.go'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: 'ubuntu-latest'
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language:
+          - go
+        
+    steps:
+    -
+      name: Checkout
+      uses: actions/checkout@v4
+    -
+      name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version-file: go.mod
+        check-latest: true
+    -
+      name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+    -
+      name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+    -
+      name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/docs-upstream.yml

@@ -0,0 +1,42 @@
+# this workflow runs the remote validate bake target from docker/docs
+# to check if yaml reference docs used in this repo are valid
+name: docs-upstream
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'v[0-9]*'
+    paths:
+      - '.github/workflows/docs-upstream.yml'
+      - 'docs/**'
+  pull_request:
+    paths:
+      - '.github/workflows/docs-upstream.yml'
+      - 'docs/**'
+
+jobs:
+  docs-yaml:
+    runs-on: ubuntu-22.04
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v4
+      -
+        name: Upload reference YAML docs
+        uses: actions/upload-artifact@v3
+        with:
+          name: docs-yaml
+          path: docs/reference
+          retention-days: 1
+
+  validate:
+    uses: docker/docs/.github/workflows/validate-upstream.yml@main
+    needs:
+      - docs-yaml
+    with:
+      module-name: docker/compose

.github/workflows/docs.yml

@@ -1,56 +0,0 @@
-name: Docs
-
-on:
-  release:
-    types: [published]
-
-permissions: {}
-jobs:
-  open-pr:
-    permissions:
-      contents: write # to create branch (peter-evans/create-pull-request)
-      pull-requests: write # to create a PR (peter-evans/create-pull-request)
-
-    runs-on: ubuntu-latest
-    steps:
-      -
-        name: Checkout docs repo
-        uses: actions/checkout@v3
-        with:
-          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
-          repository: docker/docs
-          ref: main
-      -
-        name: Prepare
-        run: |
-          rm -rf ./_data/compose-cli/*
-      -
-        name: Build
-        uses: docker/build-push-action@v3
-        with:
-          context: ${{ github.server_url }}/${{ github.repository }}.git#${{ github.event.release.name }}
-          target: docs-reference
-          outputs: ./_data/compose-cli
-      -
-        name: Update compose_version in _config.yml
-        run: |
-          sed -i "s|^compose_version\:.*|compose_version\: \"${{ github.event.release.name }}\"|g" _config.yml
-          cat _config.yml | yq .compose_version
-      -
-        name: Commit changes
-        run: |
-          git add -A .
-      -
-        name: Create PR on docs repo
-        uses: peter-evans/create-pull-request@923ad837f191474af6b1721408744feb989a4c27 # v4.0.4
-        with:
-          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
-          push-to-fork: docker-tools-robot/docker.github.io
-          commit-message: Update Compose reference API to ${{ github.event.release.name }}
-          signoff: true
-          branch: dispatch/compose-api-reference-${{ github.event.release.name }}
-          delete-branch: true
-          title: Update Compose reference API to ${{ github.event.release.name }}
-          body: |
-            Update the Compose reference API documentation to keep in sync with the latest release `${{ github.event.release.name }}`
-          draft: false

.golangci.yml

@@ -7,6 +7,7 @@ linters:
   enable:
     - depguard
     - errcheck
+    - errorlint
     - gocritic
     - gocyclo
     - gofmt
@@ -36,9 +37,18 @@ linters-settings:
         deny:
           - pkg: io/ioutil
             desc: 'io/ioutil package has been deprecated'
+          - pkg: gopkg.in/yaml.v2
+            desc: 'compose-go uses yaml.v3'
   gomodguard:
     blocked:
+      modules:
+        - github.com/pkg/errors:
+            recommendations:
+              - errors
+              - fmt
       versions:
+        - github.com/distribution/distribution:
+            reason: "use distribution/reference"
         - gotest.tools:
             version: "< 3.0.0"
             reason: "deprecated, pre-modules version"
@@ -61,5 +71,3 @@ issues:
   # golangci hides some golint warnings (the warning about exported things
   # withtout documentation for example), this will make it show them anyway.
   exclude-use-default: false
-  exclude:
-    - should not use dot imports

CONTRIBUTING.md

@@ -66,6 +66,11 @@ When sending lengthy log files, consider posting them as a gist
 Don't forget to remove sensitive data from your log files before posting (you
 can replace those parts with "REDACTED").
 
+_Note:_ 
+Maintainers might request additional information to diagnose an issue,
+if initial reporter doesn't answer within a reasonable delay (a few weeks),
+issue will be closed.
+
 ## Quick contribution tips and guidelines
 
 This section gives the experienced contributor some tips and guidelines.

Dockerfile

@@ -15,9 +15,9 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-ARG GO_VERSION=1.21.0
+ARG GO_VERSION=1.21.6
 ARG XX_VERSION=1.2.1
-ARG GOLANGCI_LINT_VERSION=v1.53.2
+ARG GOLANGCI_LINT_VERSION=v1.55.2
 ARG ADDLICENSE_VERSION=v1.0.0
 
 ARG BUILD_TAGS="e2e"
@@ -89,10 +89,13 @@ RUN --mount=type=bind,target=. \
 
 FROM build-base AS lint
 ARG BUILD_TAGS
+ENV GOLANGCI_LINT_CACHE=/cache/golangci-lint
 RUN --mount=type=bind,target=. \
     --mount=type=cache,target=/root/.cache \
     --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/cache/golangci-lint \
     --mount=from=golangci-lint,source=/usr/bin/golangci-lint,target=/usr/bin/golangci-lint \
+    golangci-lint cache status && \
     golangci-lint run --build-tags "$BUILD_TAGS" ./...
 
 FROM build-base AS test
@@ -189,9 +192,3 @@ RUN --mount=from=binary \
 
 FROM scratch AS release
 COPY --from=releaser /out/ /
-
-# docs-reference is a target used as remote context to update docs on release
-# with latest changes on docs.docker.com.
-# see open-pr job in .github/workflows/docs.yml for more details
-FROM scratch AS docs-reference
-COPY docs/reference/*.yaml .

Makefile

@@ -32,9 +32,13 @@ endif
 BUILD_FLAGS?=
 TEST_FLAGS?=
 E2E_TEST?=
-ifeq ($(E2E_TEST),)
-else
-	TEST_FLAGS=-run $(E2E_TEST)
+ifneq ($(E2E_TEST),)
+	TEST_FLAGS:=$(TEST_FLAGS) -run '$(E2E_TEST)'
+endif
+
+EXCLUDE_E2E_TESTS?=
+ifneq ($(EXCLUDE_E2E_TESTS),)
+	TEST_FLAGS:=$(TEST_FLAGS) -skip '$(EXCLUDE_E2E_TESTS)'
 endif
 
 BUILDX_CMD ?= docker buildx
@@ -71,16 +75,12 @@ install: binary
 
 .PHONY: e2e-compose
 e2e-compose: ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
-	go test $(TEST_FLAGS) -count=1 ./pkg/e2e
+	go test -v $(TEST_FLAGS) -count=1 ./pkg/e2e
 
 .PHONY: e2e-compose-standalone
 e2e-compose-standalone: ## Run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
 	go test $(TEST_FLAGS) -v -count=1 -parallel=1 --tags=standalone ./pkg/e2e
 
-.PHONY: test-cucumber
-test-cucumber:
-	go test $(TEST_FLAGS) -v -count=1 -parallel=1 ./e2e
-
 .PHONY: build-and-e2e-compose
 build-and-e2e-compose: build e2e-compose ## Compile the compose cli-plugin and run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
 
@@ -89,7 +89,7 @@ build-and-e2e-compose-standalone: build e2e-compose-standalone ## Compile the co
 
 .PHONY: mocks
 mocks:
-	mockgen --version >/dev/null 2>&1 || go install github.com/golang/mock/mockgen@v1.6.0
+	mockgen --version >/dev/null 2>&1 || go install go.uber.org/mock/mockgen@v0.3.0
 	mockgen -destination pkg/mocks/mock_docker_cli.go -package mocks github.com/docker/cli/cli/command Cli
 	mockgen -destination pkg/mocks/mock_docker_api.go -package mocks github.com/docker/docker/client APIClient
 	mockgen -destination pkg/mocks/mock_docker_compose_api.go -package mocks -source=./pkg/api/api.go Service

README.md

@@ -1,6 +1,5 @@
 # Table of Contents
 - [Docker Compose v2](#docker-compose-v2)
-- [About update and backward compatibility](#about-update-and-backward-compatibility)
 - [Where to get Docker Compose](#where-to-get-docker-compose)
     + [Windows and macOS](#windows-and-macos)
     + [Linux](#linux)
@@ -53,7 +52,7 @@ Quick Start
 Using Docker Compose is a three-step process:
 1. Define your app's environment with a `Dockerfile` so it can be
    reproduced anywhere.
-2. Define the services that make up your app in `docker-compose.yml` so
+2. Define the services that make up your app in `compose.yaml` so
    they can be run together in an isolated environment.
 3. Lastly, run `docker compose up` and Compose will start and run your entire
    app.
@@ -84,4 +83,4 @@ If you find an issue, please report it on the
 Legacy
 -------------
 
-The Python version of Compose is available under the `v1` [branch](https://github.com/docker/compose/tree/v1)
+The Python version of Compose is available under the `v1` [branch](https://github.com/docker/compose/tree/v1).

cmd/cmdtrace/cmd_span.go

@@ -29,6 +29,7 @@ import (
 	commands "github.com/docker/compose/v2/cmd/compose"
 	"github.com/docker/compose/v2/internal/tracing"
 	"github.com/spf13/cobra"
+	flag "github.com/spf13/pflag"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/trace"
@@ -42,7 +43,7 @@ import (
 // vars, creates a root span for the command, and wraps the actual
 // command invocation to ensure the span is properly finalized and
 // exported before exit.
-func Setup(cmd *cobra.Command, dockerCli command.Cli) error {
+func Setup(cmd *cobra.Command, dockerCli command.Cli, args []string) error {
 	tracingShutdown, err := tracing.InitTracing(dockerCli)
 	if err != nil {
 		return fmt.Errorf("initializing tracing: %w", err)
@@ -53,6 +54,9 @@ func Setup(cmd *cobra.Command, dockerCli command.Cli) error {
 		ctx,
 		"cli/"+strings.Join(commandName(cmd), "-"),
 	)
+	cmdSpan.SetAttributes(attribute.StringSlice("cli.args", args))
+	cmdSpan.SetAttributes(attribute.StringSlice("cli.flags", getFlags(cmd.Flags())))
+
 	cmd.SetContext(ctx)
 	wrapRunE(cmd, cmdSpan, tracingShutdown)
 	return nil
@@ -129,3 +133,11 @@ func commandName(cmd *cobra.Command) []string {
 	sort.Sort(sort.Reverse(sort.StringSlice(name)))
 	return name
 }
+
+func getFlags(fs *flag.FlagSet) []string {
+	var result []string
+	fs.Visit(func(flag *flag.Flag) {
+		result = append(result, flag.Name)
+	})
+	return result
+}

cmd/cmdtrace/cmd_span_test.go

@@ -0,0 +1,64 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package cmdtrace
+
+import (
+	"reflect"
+	"testing"
+
+	flag "github.com/spf13/pflag"
+)
+
+func TestGetFlags(t *testing.T) {
+	// Initialize flagSet with flags
+	fs := flag.NewFlagSet("up", flag.ContinueOnError)
+	var (
+		detach  string
+		timeout string
+	)
+	fs.StringVar(&detach, "detach", "d", "")
+	fs.StringVar(&timeout, "timeout", "t", "")
+	_ = fs.Set("detach", "detach")
+	_ = fs.Set("timeout", "timeout")
+
+	tests := []struct {
+		name     string
+		input    *flag.FlagSet
+		expected []string
+	}{
+		{
+			name:     "NoFlags",
+			input:    flag.NewFlagSet("NoFlags", flag.ContinueOnError),
+			expected: nil,
+		},
+		{
+			name:     "Flags",
+			input:    fs,
+			expected: []string{"detach", "timeout"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := getFlags(test.input)
+			if !reflect.DeepEqual(result, test.expected) {
+				t.Errorf("Expected %v, but got %v", test.expected, result)
+			}
+		})
+	}
+
+}

cmd/compose/alpha.go

@@ -15,12 +15,13 @@
 package compose
 
 import (
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
 
 // alphaCommand groups all experimental subcommands
-func alphaCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	cmd := &cobra.Command{
 		Short:  "Experimental commands",
 		Use:    "alpha [COMMAND]",
@@ -30,8 +31,8 @@ func alphaCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		},
 	}
 	cmd.AddCommand(
-		watchCommand(p, backend),
-		vizCommand(p, backend),
+		vizCommand(p, dockerCli, backend),
+		publishCommand(p, dockerCli, backend),
 	)
 	return cmd
 }

cmd/compose/attach.go

@@ -0,0 +1,80 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/spf13/cobra"
+)
+
+type attachOpts struct {
+	*composeOptions
+
+	service string
+	index   int
+
+	detachKeys string
+	noStdin    bool
+	proxy      bool
+}
+
+func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+	opts := attachOpts{
+		composeOptions: &composeOptions{
+			ProjectOptions: p,
+		},
+	}
+	runCmd := &cobra.Command{
+		Use:   "attach [OPTIONS] SERVICE",
+		Short: "Attach local standard input, output, and error streams to a service's running container.",
+		Args:  cobra.MinimumNArgs(1),
+		PreRunE: Adapt(func(ctx context.Context, args []string) error {
+			opts.service = args[0]
+			return nil
+		}),
+		RunE: Adapt(func(ctx context.Context, args []string) error {
+			return runAttach(ctx, dockerCli, backend, opts)
+		}),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
+	}
+
+	runCmd.Flags().IntVar(&opts.index, "index", 0, "index of the container if service has multiple replicas.")
+	runCmd.Flags().StringVarP(&opts.detachKeys, "detach-keys", "", "", "Override the key sequence for detaching from a container.")
+
+	runCmd.Flags().BoolVar(&opts.noStdin, "no-stdin", false, "Do not attach STDIN")
+	runCmd.Flags().BoolVar(&opts.proxy, "sig-proxy", true, "Proxy all received signals to the process")
+	return runCmd
+}
+
+func runAttach(ctx context.Context, dockerCli command.Cli, backend api.Service, opts attachOpts) error {
+	projectName, err := opts.toProjectName(dockerCli)
+	if err != nil {
+		return err
+	}
+
+	attachOpts := api.AttachOptions{
+		Service:    opts.service,
+		Index:      opts.index,
+		DetachKeys: opts.detachKeys,
+		NoStdin:    opts.noStdin,
+		Proxy:      opts.proxy,
+	}
+	return backend.Attach(ctx, projectName, attachOpts)
+}

cmd/compose/build.go

@@ -22,12 +22,12 @@ import (
 	"os"
 	"strings"
 
-	"github.com/compose-spec/compose-go/cli"
-	"github.com/compose-spec/compose-go/loader"
-	"github.com/compose-spec/compose-go/types"
-	buildx "github.com/docker/buildx/util/progress"
+	"github.com/compose-spec/compose-go/v2/cli"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	cliopts "github.com/docker/cli/opts"
 	ui "github.com/docker/compose/v2/pkg/progress"
+	buildkit "github.com/moby/buildkit/util/progress/progressui"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -35,7 +35,6 @@ import (
 
 type buildOptions struct {
 	*ProjectOptions
-	composeOptions
 	quiet   bool
 	pull    bool
 	push    bool
@@ -44,13 +43,21 @@ type buildOptions struct {
 	memory  cliopts.MemBytes
 	ssh     string
 	builder string
+	deps    bool
 }
 
 func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions, error) {
 	var SSHKeys []types.SSHKey
 	var err error
 	if opts.ssh != "" {
-		SSHKeys, err = loader.ParseShortSSHSyntax(opts.ssh)
+		id, path, found := strings.Cut(opts.ssh, "=")
+		if !found && id != "default" {
+			return api.BuildOptions{}, fmt.Errorf("invalid ssh key %q", opts.ssh)
+		}
+		SSHKeys = append(SSHKeys, types.SSHKey{
+			ID:   id,
+			Path: path,
+		})
 		if err != nil {
 			return api.BuildOptions{}, err
 		}
@@ -68,12 +75,13 @@ func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions,
 		NoCache:  opts.noCache,
 		Quiet:    opts.quiet,
 		Services: services,
+		Deps:     opts.deps,
 		SSHs:     SSHKeys,
 		Builder:  builderName,
 	}, nil
 }
 
-func buildCommand(p *ProjectOptions, progress *string, backend api.Service) *cobra.Command {
+func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := buildOptions{
 		ProjectOptions: p,
 	}
@@ -96,40 +104,47 @@ func buildCommand(p *ProjectOptions, progress *string, backend api.Service) *cob
 				opts.ssh = "default"
 			}
 			if cmd.Flags().Changed("progress") && opts.ssh == "" {
-				fmt.Fprint(os.Stderr, "--progress is a global compose flag, better use `docker compose --progress xx build ...")
+				fmt.Fprint(os.Stderr, "--progress is a global compose flag, better use `docker compose --progress xx build ...\n")
 			}
-			return runBuild(ctx, backend, opts, args)
+			return runBuild(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
-	cmd.Flags().BoolVar(&opts.push, "push", false, "Push service images.")
-	cmd.Flags().BoolVarP(&opts.quiet, "quiet", "q", false, "Don't print anything to STDOUT")
-	cmd.Flags().BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image.")
-	cmd.Flags().StringArrayVar(&opts.args, "build-arg", []string{}, "Set build-time variables for services.")
-	cmd.Flags().StringVar(&opts.ssh, "ssh", "", "Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)")
-	cmd.Flags().StringVar(&opts.builder, "builder", "", "Set builder to use.")
-	cmd.Flags().Bool("parallel", true, "Build images in parallel. DEPRECATED")
-	cmd.Flags().MarkHidden("parallel") //nolint:errcheck
-	cmd.Flags().Bool("compress", true, "Compress the build context using gzip. DEPRECATED")
-	cmd.Flags().MarkHidden("compress") //nolint:errcheck
-	cmd.Flags().Bool("force-rm", true, "Always remove intermediate containers. DEPRECATED")
-	cmd.Flags().MarkHidden("force-rm") //nolint:errcheck
-	cmd.Flags().BoolVar(&opts.noCache, "no-cache", false, "Do not use cache when building the image")
-	cmd.Flags().Bool("no-rm", false, "Do not remove intermediate containers after a successful build. DEPRECATED")
-	cmd.Flags().MarkHidden("no-rm") //nolint:errcheck
-	cmd.Flags().VarP(&opts.memory, "memory", "m", "Set memory limit for the build container. Not supported by BuildKit.")
-	cmd.Flags().StringVar(progress, "progress", buildx.PrinterModeAuto, fmt.Sprintf(`Set type of ui output (%s)`, strings.Join(printerModes, ", ")))
-	cmd.Flags().MarkHidden("progress") //nolint:errcheck
+	flags := cmd.Flags()
+	flags.BoolVar(&opts.push, "push", false, "Push service images.")
+	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Don't print anything to STDOUT")
+	flags.BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image.")
+	flags.StringArrayVar(&opts.args, "build-arg", []string{}, "Set build-time variables for services.")
+	flags.StringVar(&opts.ssh, "ssh", "", "Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)")
+	flags.StringVar(&opts.builder, "builder", "", "Set builder to use.")
+	flags.BoolVar(&opts.deps, "with-dependencies", false, "Also build dependencies (transitively).")
+
+	flags.Bool("parallel", true, "Build images in parallel. DEPRECATED")
+	flags.MarkHidden("parallel") //nolint:errcheck
+	flags.Bool("compress", true, "Compress the build context using gzip. DEPRECATED")
+	flags.MarkHidden("compress") //nolint:errcheck
+	flags.Bool("force-rm", true, "Always remove intermediate containers. DEPRECATED")
+	flags.MarkHidden("force-rm") //nolint:errcheck
+	flags.BoolVar(&opts.noCache, "no-cache", false, "Do not use cache when building the image")
+	flags.Bool("no-rm", false, "Do not remove intermediate containers after a successful build. DEPRECATED")
+	flags.MarkHidden("no-rm") //nolint:errcheck
+	flags.VarP(&opts.memory, "memory", "m", "Set memory limit for the build container. Not supported by BuildKit.")
+	flags.StringVar(&p.Progress, "progress", string(buildkit.AutoMode), fmt.Sprintf(`Set type of ui output (%s)`, strings.Join(printerModes, ", ")))
+	flags.MarkHidden("progress") //nolint:errcheck
 
 	return cmd
 }
 
-func runBuild(ctx context.Context, backend api.Service, opts buildOptions, services []string) error {
-	project, err := opts.ToProject(services, cli.WithResolvedPaths(true))
+func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Service, opts buildOptions, services []string) error {
+	project, err := opts.ToProject(dockerCli, services, cli.WithResolvedPaths(true), cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
 
+	if err := applyPlatforms(project, false); err != nil {
+		return err
+	}
+
 	apiBuildOptions, err := opts.toAPIBuildOptions(services)
 	if err != nil {
 		return err

cmd/compose/completion.go

@@ -20,6 +20,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -33,14 +34,15 @@ func noCompletion() validArgsFn {
 	}
 }
 
-func completeServiceNames(p *ProjectOptions) validArgsFn {
+func completeServiceNames(dockerCli command.Cli, p *ProjectOptions) validArgsFn {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		project, err := p.ToProject(nil)
+		p.Offline = true
+		project, err := p.ToProject(dockerCli, nil)
 		if err != nil {
 			return nil, cobra.ShellCompDirectiveNoFileComp
 		}
-		var serviceNames []string
-		for _, s := range project.ServiceNames() {
+		serviceNames := append(project.ServiceNames(), project.DisabledServiceNames()...)
+		for _, s := range serviceNames {
 			if toComplete == "" || strings.HasPrefix(s, toComplete) {
 				serviceNames = append(serviceNames, s)
 			}
@@ -67,9 +69,10 @@ func completeProjectNames(backend api.Service) func(cmd *cobra.Command, args []s
 	}
 }
 
-func completeProfileNames(p *ProjectOptions) validArgsFn {
+func completeProfileNames(dockerCli command.Cli, p *ProjectOptions) validArgsFn {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		project, err := p.ToProject(nil)
+		p.Offline = true
+		project, err := p.ToProject(dockerCli, nil)
 		if err != nil {
 			return nil, cobra.ShellCompDirectiveNoFileComp
 		}

cmd/compose/compose.go

@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/signal"
@@ -26,18 +27,17 @@ import (
 	"strings"
 	"syscall"
 
-	"github.com/compose-spec/compose-go/dotenv"
-	buildx "github.com/docker/buildx/util/progress"
-	"github.com/docker/cli/cli/command"
-
-	"github.com/compose-spec/compose-go/cli"
-	"github.com/compose-spec/compose-go/types"
-	composegoutils "github.com/compose-spec/compose-go/utils"
+	"github.com/compose-spec/compose-go/v2/cli"
+	"github.com/compose-spec/compose-go/v2/dotenv"
+	"github.com/compose-spec/compose-go/v2/types"
+	composegoutils "github.com/compose-spec/compose-go/v2/utils"
 	"github.com/docker/buildx/util/logutil"
 	dockercli "github.com/docker/cli/cli"
 	"github.com/docker/cli/cli-plugins/manager"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose/v2/pkg/remote"
+	buildkit "github.com/moby/buildkit/util/progress/progressui"
 	"github.com/morikuni/aec"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -60,6 +60,8 @@ const (
 	ComposeRemoveOrphans = "COMPOSE_REMOVE_ORPHANS"
 	// ComposeIgnoreOrphans ignore "orphaned" containers
 	ComposeIgnoreOrphans = "COMPOSE_IGNORE_ORPHANS"
+	// ComposeEnvFiles defines the env files to use if --env-file isn't used
+	ComposeEnvFiles = "COMPOSE_ENV_FILES"
 )
 
 // Command defines a compose CLI command as a func with args
@@ -71,18 +73,17 @@ type CobraCommand func(context.Context, *cobra.Command, []string) error
 // AdaptCmd adapt a CobraCommand func to cobra library
 func AdaptCmd(fn CobraCommand) func(cmd *cobra.Command, args []string) error {
 	return func(cmd *cobra.Command, args []string) error {
-		ctx := cmd.Context()
-		contextString := fmt.Sprintf("%s", ctx)
-		if !strings.HasSuffix(contextString, ".WithCancel") { // need to handle cancel
-			cancellableCtx, cancel := context.WithCancel(cmd.Context())
-			ctx = cancellableCtx
-			s := make(chan os.Signal, 1)
-			signal.Notify(s, syscall.SIGTERM, syscall.SIGINT)
-			go func() {
-				<-s
-				cancel()
-			}()
-		}
+		ctx, cancel := context.WithCancel(cmd.Context())
+
+		s := make(chan os.Signal, 1)
+		signal.Notify(s, syscall.SIGTERM, syscall.SIGINT)
+		go func() {
+			<-s
+			cancel()
+			signal.Stop(s)
+			close(s)
+		}()
+
 		err := fn(ctx, cmd, args)
 		var composeErr compose.Error
 		if api.IsErrCanceled(err) || errors.Is(ctx.Err(), context.Canceled) {
@@ -116,6 +117,8 @@ type ProjectOptions struct {
 	ProjectDir    string
 	EnvFiles      []string
 	Compatibility bool
+	Progress      string
+	Offline       bool
 }
 
 // ProjectFunc does stuff within a types.Project
@@ -125,16 +128,22 @@ type ProjectFunc func(ctx context.Context, project *types.Project) error
 type ProjectServicesFunc func(ctx context.Context, project *types.Project, services []string) error
 
 // WithProject creates a cobra run command from a ProjectFunc based on configured project options and selected services
-func (o *ProjectOptions) WithProject(fn ProjectFunc) func(cmd *cobra.Command, args []string) error {
-	return o.WithServices(func(ctx context.Context, project *types.Project, services []string) error {
+func (o *ProjectOptions) WithProject(fn ProjectFunc, dockerCli command.Cli) func(cmd *cobra.Command, args []string) error {
+	return o.WithServices(dockerCli, func(ctx context.Context, project *types.Project, services []string) error {
 		return fn(ctx, project)
 	})
 }
 
 // WithServices creates a cobra run command from a ProjectFunc based on configured project options and selected services
-func (o *ProjectOptions) WithServices(fn ProjectServicesFunc) func(cmd *cobra.Command, args []string) error {
+func (o *ProjectOptions) WithServices(dockerCli command.Cli, fn ProjectServicesFunc) func(cmd *cobra.Command, args []string) error {
 	return Adapt(func(ctx context.Context, args []string) error {
-		project, err := o.ToProject(args, cli.WithResolvedPaths(true), cli.WithDiscardEnvFile)
+		options := []cli.ProjectOptionsFn{
+			cli.WithResolvedPaths(true),
+			cli.WithDiscardEnvFile,
+			cli.WithContext(ctx),
+		}
+
+		project, err := o.ToProject(dockerCli, args, options...)
 		if err != nil {
 			return err
 		}
@@ -151,14 +160,15 @@ func (o *ProjectOptions) addProjectFlags(f *pflag.FlagSet) {
 	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the, first specified, Compose file)")
 	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the, first specified, Compose file)")
 	f.BoolVar(&o.Compatibility, "compatibility", false, "Run compose in backward compatibility mode")
+	f.StringVar(&o.Progress, "progress", string(buildkit.AutoMode), fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
 	_ = f.MarkHidden("workdir")
 }
 
-func (o *ProjectOptions) projectOrName(services ...string) (*types.Project, string, error) {
+func (o *ProjectOptions) projectOrName(dockerCli command.Cli, services ...string) (*types.Project, string, error) {
 	name := o.ProjectName
 	var project *types.Project
 	if len(o.ConfigPaths) > 0 || o.ProjectName == "" {
-		p, err := o.ToProject(services, cli.WithDiscardEnvFile)
+		p, err := o.ToProject(dockerCli, services, cli.WithDiscardEnvFile)
 		if err != nil {
 			envProjectName := os.Getenv(ComposeProjectName)
 			if envProjectName != "" {
@@ -172,7 +182,7 @@ func (o *ProjectOptions) projectOrName(services ...string) (*types.Project, stri
 	return project, name, nil
 }
 
-func (o *ProjectOptions) toProjectName() (string, error) {
+func (o *ProjectOptions) toProjectName(dockerCli command.Cli) (string, error) {
 	if o.ProjectName != "" {
 		return o.ProjectName, nil
 	}
@@ -182,14 +192,18 @@ func (o *ProjectOptions) toProjectName() (string, error) {
 		return envProjectName, nil
 	}
 
-	project, err := o.ToProject(nil)
+	project, err := o.ToProject(dockerCli, nil)
 	if err != nil {
 		return "", err
 	}
 	return project.Name, nil
 }
 
-func (o *ProjectOptions) ToProject(services []string, po ...cli.ProjectOptionsFn) (*types.Project, error) {
+func (o *ProjectOptions) ToProject(dockerCli command.Cli, services []string, po ...cli.ProjectOptionsFn) (*types.Project, error) {
+	if !o.Offline {
+		po = o.configureRemoteLoaders(dockerCli, po)
+	}
+
 	options, err := o.toProjectOptions(po...)
 	if err != nil {
 		return nil, compose.WrapComposeError(err)
@@ -208,15 +222,15 @@ func (o *ProjectOptions) ToProject(services []string, po ...cli.ProjectOptionsFn
 		return nil, errors.New("project name can't be empty. Use `--project-name` to set a valid name")
 	}
 
-	err = project.EnableServices(services...)
+	project, err = project.WithServicesEnabled(services...)
 	if err != nil {
 		return nil, err
 	}
 
-	for i, s := range project.Services {
+	for name, s := range project.Services {
 		s.CustomLabels = map[string]string{
 			api.ProjectLabel:     project.Name,
-			api.ServiceLabel:     s.Name,
+			api.ServiceLabel:     name,
 			api.VersionLabel:     api.ComposeVersion,
 			api.WorkingDirLabel:  project.WorkingDir,
 			api.ConfigFilesLabel: strings.Join(project.ComposeFiles, ","),
@@ -225,15 +239,23 @@ func (o *ProjectOptions) ToProject(services []string, po ...cli.ProjectOptionsFn
 		if len(o.EnvFiles) != 0 {
 			s.CustomLabels[api.EnvironmentFileLabel] = strings.Join(o.EnvFiles, ",")
 		}
-		project.Services[i] = s
+		project.Services[name] = s
 	}
 
-	project.WithoutUnnecessaryResources()
+	project = project.WithoutUnnecessaryResources()
 
-	err = project.ForServices(services)
+	project, err = project.WithSelectedServices(services)
 	return project, err
 }
 
+func (o *ProjectOptions) configureRemoteLoaders(dockerCli command.Cli, po []cli.ProjectOptionsFn) []cli.ProjectOptionsFn {
+	git := remote.NewGitRemoteLoader(o.Offline)
+	oci := remote.NewOCIRemoteLoader(dockerCli, o.Offline)
+
+	po = append(po, cli.WithResourceLoader(git), cli.WithResourceLoader(oci))
+	return po
+}
+
 func (o *ProjectOptions) toProjectOptions(po ...cli.ProjectOptionsFn) (*cli.ProjectOptions, error) {
 	return cli.NewProjectOptions(o.ConfigPaths,
 		append(po,
@@ -243,7 +265,7 @@ func (o *ProjectOptions) toProjectOptions(po ...cli.ProjectOptionsFn) (*cli.Proj
 			cli.WithDotEnv,
 			cli.WithConfigFileEnv,
 			cli.WithDefaultConfigPath,
-			cli.WithProfiles(o.Profiles),
+			cli.WithDefaultProfiles(o.Profiles...),
 			cli.WithName(o.ProjectName))...)
 }
 
@@ -256,7 +278,7 @@ func RunningAsStandalone() bool {
 }
 
 // RootCommand returns the compose command with its child commands
-func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //nolint:gocyclo
+func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //nolint:gocyclo
 	// filter out useless commandConn.CloseWrite warning message that can occur
 	// when using a remote context that is unreachable: "commandConn.CloseWrite: commandconn: failed to wait: signal: killed"
 	// https://github.com/docker/cli/blob/e1f24d3c93df6752d3c27c8d61d18260f141310c/cli/connhelper/commandconn/commandconn.go#L203-L215
@@ -275,7 +297,6 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 		version  bool
 		parallel int
 		dryRun   bool
-		progress string
 	)
 	c := &cobra.Command{
 		Short:            "Docker Compose",
@@ -288,7 +309,7 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 				return cmd.Help()
 			}
 			if version {
-				return versionCommand(streams).Execute()
+				return versionCommand(dockerCli).Execute()
 			}
 			_ = cmd.Help()
 			return dockercli.StatusError{
@@ -326,11 +347,11 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 				ansi = v
 			}
 
-			formatter.SetANSIMode(streams, ansi)
+			formatter.SetANSIMode(dockerCli, ansi)
 
 			if noColor, ok := os.LookupEnv("NO_COLOR"); ok && noColor != "" {
 				ui.NoColor()
-				formatter.SetANSIMode(streams, formatter.Never)
+				formatter.SetANSIMode(dockerCli, formatter.Never)
 			}
 
 			switch ansi {
@@ -340,7 +361,7 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 				ui.Mode = ui.ModeTTY
 			}
 
-			switch progress {
+			switch opts.Progress {
 			case ui.ModeAuto:
 				ui.Mode = ui.ModeAuto
 			case ui.ModeTTY:
@@ -356,7 +377,7 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 			case ui.ModeQuiet, "none":
 				ui.Mode = ui.ModeQuiet
 			default:
-				return fmt.Errorf("unsupported --progress value %q", progress)
+				return fmt.Errorf("unsupported --progress value %q", opts.Progress)
 			}
 
 			if opts.WorkDir != "" {
@@ -407,33 +428,37 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 	}
 
 	c.AddCommand(
-		upCommand(&opts, streams, backend),
-		downCommand(&opts, backend),
-		startCommand(&opts, backend),
-		restartCommand(&opts, backend),
-		stopCommand(&opts, backend),
-		psCommand(&opts, streams, backend),
-		listCommand(streams, backend),
-		logsCommand(&opts, streams, backend),
-		configCommand(&opts, streams, backend),
-		killCommand(&opts, backend),
-		runCommand(&opts, streams, backend),
-		removeCommand(&opts, backend),
-		execCommand(&opts, streams, backend),
-		pauseCommand(&opts, backend),
-		unpauseCommand(&opts, backend),
-		topCommand(&opts, streams, backend),
-		eventsCommand(&opts, streams, backend),
-		portCommand(&opts, streams, backend),
-		imagesCommand(&opts, streams, backend),
-		versionCommand(streams),
-		buildCommand(&opts, &progress, backend),
-		pushCommand(&opts, backend),
-		pullCommand(&opts, backend),
-		createCommand(&opts, backend),
-		copyCommand(&opts, backend),
-		waitCommand(&opts, backend),
-		alphaCommand(&opts, backend),
+		upCommand(&opts, dockerCli, backend),
+		downCommand(&opts, dockerCli, backend),
+		startCommand(&opts, dockerCli, backend),
+		restartCommand(&opts, dockerCli, backend),
+		stopCommand(&opts, dockerCli, backend),
+		psCommand(&opts, dockerCli, backend),
+		listCommand(dockerCli, backend),
+		logsCommand(&opts, dockerCli, backend),
+		configCommand(&opts, dockerCli, backend),
+		killCommand(&opts, dockerCli, backend),
+		runCommand(&opts, dockerCli, backend),
+		removeCommand(&opts, dockerCli, backend),
+		execCommand(&opts, dockerCli, backend),
+		attachCommand(&opts, dockerCli, backend),
+		pauseCommand(&opts, dockerCli, backend),
+		unpauseCommand(&opts, dockerCli, backend),
+		topCommand(&opts, dockerCli, backend),
+		eventsCommand(&opts, dockerCli, backend),
+		portCommand(&opts, dockerCli, backend),
+		imagesCommand(&opts, dockerCli, backend),
+		versionCommand(dockerCli),
+		buildCommand(&opts, dockerCli, backend),
+		pushCommand(&opts, dockerCli, backend),
+		pullCommand(&opts, dockerCli, backend),
+		createCommand(&opts, dockerCli, backend),
+		copyCommand(&opts, dockerCli, backend),
+		waitCommand(&opts, dockerCli, backend),
+		scaleCommand(&opts, dockerCli, backend),
+		statsCommand(&opts, dockerCli),
+		watchCommand(&opts, dockerCli, backend),
+		alphaCommand(&opts, dockerCli, backend),
 	)
 
 	c.Flags().SetInterspersed(false)
@@ -456,11 +481,9 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 	)
 	c.RegisterFlagCompletionFunc( //nolint:errcheck
 		"profile",
-		completeProfileNames(&opts),
+		completeProfileNames(dockerCli, &opts),
 	)
 
-	c.Flags().StringVar(&progress, "progress", buildx.PrinterModeAuto, fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
-
 	c.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
 	c.Flags().IntVar(&parallel, "parallel", -1, `Control max parallelism, -1 for unlimited`)
 	c.Flags().BoolVarP(&version, "version", "v", false, "Show the Docker Compose version information")
@@ -474,16 +497,17 @@ func RootCommand(streams command.Cli, backend api.Service) *cobra.Command { //no
 }
 
 func setEnvWithDotEnv(prjOpts *ProjectOptions) error {
+	if len(prjOpts.EnvFiles) == 0 {
+		if envFiles := os.Getenv(ComposeEnvFiles); envFiles != "" {
+			prjOpts.EnvFiles = strings.Split(envFiles, ",")
+		}
+	}
 	options, err := prjOpts.toProjectOptions()
 	if err != nil {
 		return compose.WrapComposeError(err)
 	}
-	workingDir, err := options.GetWorkingDir()
-	if err != nil {
-		return err
-	}
 
-	envFromFile, err := dotenv.GetEnvFromFile(composegoutils.GetAsEqualsMap(os.Environ()), workingDir, options.EnvFiles)
+	envFromFile, err := dotenv.GetEnvFromFile(composegoutils.GetAsEqualsMap(os.Environ()), options.EnvFiles)
 	if err != nil {
 		return err
 	}

cmd/compose/compose_test.go

@@ -19,32 +19,32 @@ package compose
 import (
 	"testing"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
 	"gotest.tools/v3/assert"
 )
 
 func TestFilterServices(t *testing.T) {
 	p := &types.Project{
-		Services: []types.ServiceConfig{
-			{
+		Services: types.Services{
+			"foo": {
 				Name:  "foo",
 				Links: []string{"bar"},
 			},
-			{
+			"bar": {
 				Name: "bar",
 				DependsOn: map[string]types.ServiceDependency{
 					"zot": {},
 				},
 			},
-			{
+			"zot": {
 				Name: "zot",
 			},
-			{
+			"qix": {
 				Name: "qix",
 			},
 		},
 	}
-	err := p.ForServices([]string{"bar"})
+	p, err := p.WithSelectedServices([]string{"bar"})
 	assert.NilError(t, err)
 
 	assert.Equal(t, len(p.Services), 2)

cmd/compose/config.go

@@ -24,8 +24,9 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/compose-spec/compose-go/cli"
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/cli"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -49,17 +50,19 @@ type configOptions struct {
 	noConsistency       bool
 }
 
-func (o *configOptions) ToProject(services []string) (*types.Project, error) {
-	return o.ProjectOptions.ToProject(services,
+func (o *configOptions) ToProject(ctx context.Context, dockerCli command.Cli, services []string, po ...cli.ProjectOptionsFn) (*types.Project, error) {
+	po = append(po,
 		cli.WithInterpolation(!o.noInterpolate),
 		cli.WithResolvedPaths(!o.noResolvePath),
 		cli.WithNormalization(!o.noNormalize),
 		cli.WithConsistency(!o.noConsistency),
-		cli.WithProfiles(o.Profiles),
-		cli.WithDiscardEnvFile)
+		cli.WithDefaultProfiles(o.Profiles...),
+		cli.WithDiscardEnvFile,
+		cli.WithContext(ctx))
+	return o.ProjectOptions.ToProject(dockerCli, services, po...)
 }
 
-func configCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func configCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := configOptions{
 		ProjectOptions: p,
 	}
@@ -82,24 +85,24 @@ func configCommand(p *ProjectOptions, streams api.Streams, backend api.Service)
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.services {
-				return runServices(streams, opts)
+				return runServices(ctx, dockerCli, opts)
 			}
 			if opts.volumes {
-				return runVolumes(streams, opts)
+				return runVolumes(ctx, dockerCli, opts)
 			}
 			if opts.hash != "" {
-				return runHash(streams, opts)
+				return runHash(ctx, dockerCli, opts)
 			}
 			if opts.profiles {
-				return runProfiles(streams, opts, args)
+				return runProfiles(ctx, dockerCli, opts, args)
 			}
 			if opts.images {
-				return runConfigImages(streams, opts, args)
+				return runConfigImages(ctx, dockerCli, opts, args)
 			}
 
-			return runConfig(ctx, streams, backend, opts, args)
+			return runConfig(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
 	flags.StringVar(&opts.Format, "format", "yaml", "Format the output. Values: [yaml | json]")
@@ -120,9 +123,9 @@ func configCommand(p *ProjectOptions, streams api.Streams, backend api.Service)
 	return cmd
 }
 
-func runConfig(ctx context.Context, streams api.Streams, backend api.Service, opts configOptions, services []string) error {
+func runConfig(ctx context.Context, dockerCli command.Cli, backend api.Service, opts configOptions, services []string) error {
 	var content []byte
-	project, err := opts.ToProject(services)
+	project, err := opts.ToProject(ctx, dockerCli, services)
 	if err != nil {
 		return err
 	}
@@ -147,67 +150,75 @@ func runConfig(ctx context.Context, streams api.Streams, backend api.Service, op
 	if opts.Output != "" && len(content) > 0 {
 		return os.WriteFile(opts.Output, content, 0o666)
 	}
-	_, err = fmt.Fprint(streams.Out(), string(content))
+	_, err = fmt.Fprint(dockerCli.Out(), string(content))
 	return err
 }
 
-func runServices(streams api.Streams, opts configOptions) error {
-	project, err := opts.ToProject(nil)
+func runServices(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
+	project, err := opts.ToProject(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
-	return project.WithServices(project.ServiceNames(), func(s types.ServiceConfig) error {
-		fmt.Fprintln(streams.Out(), s.Name)
+	err = project.ForEachService(project.ServiceNames(), func(serviceName string, _ *types.ServiceConfig) error {
+		fmt.Fprintln(dockerCli.Out(), serviceName)
 		return nil
 	})
+	return err
 }
 
-func runVolumes(streams api.Streams, opts configOptions) error {
-	project, err := opts.ToProject(nil)
+func runVolumes(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
+	project, err := opts.ToProject(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
 	for n := range project.Volumes {
-		fmt.Fprintln(streams.Out(), n)
+		fmt.Fprintln(dockerCli.Out(), n)
 	}
 	return nil
 }
 
-func runHash(streams api.Streams, opts configOptions) error {
+func runHash(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
 	var services []string
 	if opts.hash != "*" {
 		services = append(services, strings.Split(opts.hash, ",")...)
 	}
-	project, err := opts.ToProject(nil)
+	project, err := opts.ToProject(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
 
-	if len(services) > 0 {
-		err = project.ForServices(services, types.IgnoreDependencies)
-		if err != nil {
-			return err
-		}
+	if err := applyPlatforms(project, true); err != nil {
+		return err
 	}
 
-	sorted := project.Services
+	if len(services) == 0 {
+		services = project.ServiceNames()
+	}
+
+	sorted := services
 	sort.Slice(sorted, func(i, j int) bool {
-		return sorted[i].Name < sorted[j].Name
+		return sorted[i] < sorted[j]
 	})
 
-	for _, s := range sorted {
-		hash, err := compose.ServiceHash(s)
+	for _, name := range sorted {
+		s, err := project.GetService(name)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(streams.Out(), "%s %s\n", s.Name, hash)
+
+		hash, err := compose.ServiceHash(s)
+
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(dockerCli.Out(), "%s %s\n", name, hash)
 	}
 	return nil
 }
 
-func runProfiles(streams api.Streams, opts configOptions, services []string) error {
+func runProfiles(ctx context.Context, dockerCli command.Cli, opts configOptions, services []string) error {
 	set := map[string]struct{}{}
-	project, err := opts.ToProject(services)
+	project, err := opts.ToProject(ctx, dockerCli, services, cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
@@ -222,18 +233,18 @@ func runProfiles(streams api.Streams, opts configOptions, services []string) err
 	}
 	sort.Strings(profiles)
 	for _, p := range profiles {
-		fmt.Fprintln(streams.Out(), p)
+		fmt.Fprintln(dockerCli.Out(), p)
 	}
 	return nil
 }
 
-func runConfigImages(streams api.Streams, opts configOptions, services []string) error {
-	project, err := opts.ToProject(services)
+func runConfigImages(ctx context.Context, dockerCli command.Cli, opts configOptions, services []string) error {
+	project, err := opts.ToProject(ctx, dockerCli, services, cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
 	for _, s := range project.Services {
-		fmt.Fprintln(streams.Out(), api.GetImageNameOrDefault(s, project.Name))
+		fmt.Fprintln(dockerCli.Out(), api.GetImageNameOrDefault(s, project.Name))
 	}
 	return nil
 }

cmd/compose/cp.go

@@ -21,6 +21,7 @@ import (
 	"errors"
 
 	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -37,7 +38,7 @@ type copyOptions struct {
 	copyUIDGID  bool
 }
 
-func copyCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := copyOptions{
 		ProjectOptions: p,
 	}
@@ -58,9 +59,9 @@ func copyCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
 			opts.source = args[0]
 			opts.destination = args[1]
-			return runCopy(ctx, backend, opts)
+			return runCopy(ctx, dockerCli, backend, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 
 	flags := copyCmd.Flags()
@@ -74,8 +75,8 @@ func copyCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return copyCmd
 }
 
-func runCopy(ctx context.Context, backend api.Service, opts copyOptions) error {
-	name, err := opts.toProjectName()
+func runCopy(ctx context.Context, dockerCli command.Cli, backend api.Service, opts copyOptions) error {
+	name, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}

cmd/compose/create.go

@@ -19,11 +19,13 @@ package compose
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -46,8 +48,11 @@ type createOptions struct {
 	scale         []string
 }
 
-func createCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func createCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := createOptions{}
+	buildOpts := buildOptions{
+		ProjectOptions: p,
+	}
 	cmd := &cobra.Command{
 		Use:   "create [OPTIONS] [SERVICE...]",
 		Short: "Creates containers for a service.",
@@ -61,26 +66,15 @@ func createCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			}
 			return nil
 		}),
-		RunE: p.WithProject(func(ctx context.Context, project *types.Project) error {
-			if err := opts.Apply(project); err != nil {
-				return err
-			}
-			return backend.Create(ctx, project, api.CreateOptions{
-				RemoveOrphans:        opts.removeOrphans,
-				IgnoreOrphans:        opts.ignoreOrphans,
-				Recreate:             opts.recreateStrategy(),
-				RecreateDependencies: opts.dependenciesRecreateStrategy(),
-				Inherit:              !opts.noInherit,
-				Timeout:              opts.GetTimeout(),
-				QuietPull:            false,
-			})
+		RunE: p.WithServices(dockerCli, func(ctx context.Context, project *types.Project, services []string) error {
+			return runCreate(ctx, dockerCli, backend, opts, buildOpts, project, services)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVar(&opts.Build, "build", false, "Build images before starting containers.")
-	flags.BoolVar(&opts.noBuild, "no-build", false, "Don't build an image, even if it's missing.")
-	flags.StringVar(&opts.Pull, "pull", "missing", `Pull image before running ("always"|"missing"|"never")`)
+	flags.BoolVar(&opts.noBuild, "no-build", false, "Don't build an image, even if it's policy.")
+	flags.StringVar(&opts.Pull, "pull", "policy", `Pull image before running ("always"|"missing"|"never"|"build")`)
 	flags.BoolVar(&opts.forceRecreate, "force-recreate", false, "Recreate containers even if their configuration and image haven't changed.")
 	flags.BoolVar(&opts.noRecreate, "no-recreate", false, "If containers already exist, don't recreate them. Incompatible with --force-recreate.")
 	flags.BoolVar(&opts.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file.")
@@ -88,6 +82,33 @@ func createCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
+func runCreate(ctx context.Context, _ command.Cli, backend api.Service, createOpts createOptions, buildOpts buildOptions, project *types.Project, services []string) error {
+	if err := createOpts.Apply(project); err != nil {
+		return err
+	}
+
+	var build *api.BuildOptions
+	if !createOpts.noBuild {
+		bo, err := buildOpts.toAPIBuildOptions(services)
+		if err != nil {
+			return err
+		}
+		build = &bo
+	}
+
+	return backend.Create(ctx, project, api.CreateOptions{
+		Build:                build,
+		Services:             services,
+		RemoveOrphans:        createOpts.removeOrphans,
+		IgnoreOrphans:        createOpts.ignoreOrphans,
+		Recreate:             createOpts.recreateStrategy(),
+		RecreateDependencies: createOpts.dependenciesRecreateStrategy(),
+		Inherit:              !createOpts.noInherit,
+		Timeout:              createOpts.GetTimeout(),
+		QuietPull:            false,
+	})
+}
+
 func (opts createOptions) recreateStrategy() string {
 	if opts.noRecreate {
 		return api.RecreateNever
@@ -118,11 +139,17 @@ func (opts createOptions) GetTimeout() *time.Duration {
 
 func (opts createOptions) Apply(project *types.Project) error {
 	if opts.pullChanged {
+		if !opts.isPullPolicyValid() {
+			return fmt.Errorf("invalid --pull option %q", opts.Pull)
+		}
 		for i, service := range project.Services {
 			service.PullPolicy = opts.Pull
 			project.Services[i] = service
 		}
 	}
+	// N.B. opts.Build means "force build all", but images can still be built
+	// when this is false
+	// e.g. if a service has pull_policy: build or its local image is policy
 	if opts.Build {
 		for i, service := range project.Services {
 			if service.Build == nil {
@@ -132,16 +159,20 @@ func (opts createOptions) Apply(project *types.Project) error {
 			project.Services[i] = service
 		}
 	}
-	if opts.noBuild {
-		for i, service := range project.Services {
-			service.Build = nil
-			if service.Image == "" {
-				service.Image = api.GetImageNameOrDefault(service, project.Name)
-			}
-			project.Services[i] = service
-		}
+
+	if err := applyPlatforms(project, true); err != nil {
+		return err
 	}
-	for _, scale := range opts.scale {
+
+	err := applyScaleOpts(project, opts.scale)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func applyScaleOpts(project *types.Project, opts []string) error {
+	for _, scale := range opts {
 		split := strings.Split(scale, "=")
 		if len(split) != 2 {
 			return fmt.Errorf("invalid --scale option %q. Should be SERVICE=NUM", scale)
@@ -151,10 +182,16 @@ func (opts createOptions) Apply(project *types.Project) error {
 		if err != nil {
 			return err
 		}
-		err = setServiceScale(project, name, uint64(replicas))
+		err = setServiceScale(project, name, replicas)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+func (opts createOptions) isPullPolicyValid() bool {
+	pullPolicies := []string{types.PullPolicyAlways, types.PullPolicyNever, types.PullPolicyBuild,
+		types.PullPolicyMissing, types.PullPolicyIfNotPresent}
+	return slices.Contains(pullPolicies, opts.Pull)
+}

cmd/compose/create_test.go

@@ -0,0 +1,170 @@
+/*
+   Copyright 2023 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/mocks"
+	"github.com/google/go-cmp/cmp"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+)
+
+func TestRunCreate(t *testing.T) {
+	ctrl, ctx := gomock.WithContext(context.Background(), t)
+	backend := mocks.NewMockService(ctrl)
+	backend.EXPECT().Create(
+		gomock.Eq(ctx),
+		pullPolicy(""),
+		deepEqual(defaultCreateOptions(true)),
+	)
+
+	createOpts := createOptions{}
+	buildOpts := buildOptions{}
+	project := sampleProject()
+	err := runCreate(ctx, nil, backend, createOpts, buildOpts, project, nil)
+	require.NoError(t, err)
+}
+
+func TestRunCreate_Build(t *testing.T) {
+	ctrl, ctx := gomock.WithContext(context.Background(), t)
+	backend := mocks.NewMockService(ctrl)
+	backend.EXPECT().Create(
+		gomock.Eq(ctx),
+		pullPolicy("build"),
+		deepEqual(defaultCreateOptions(true)),
+	)
+
+	createOpts := createOptions{
+		Build: true,
+	}
+	buildOpts := buildOptions{}
+	project := sampleProject()
+	err := runCreate(ctx, nil, backend, createOpts, buildOpts, project, nil)
+	require.NoError(t, err)
+}
+
+func TestRunCreate_NoBuild(t *testing.T) {
+	ctrl, ctx := gomock.WithContext(context.Background(), t)
+	backend := mocks.NewMockService(ctrl)
+	backend.EXPECT().Create(
+		gomock.Eq(ctx),
+		pullPolicy(""),
+		deepEqual(defaultCreateOptions(false)),
+	)
+
+	createOpts := createOptions{
+		noBuild: true,
+	}
+	buildOpts := buildOptions{}
+	project := sampleProject()
+	err := runCreate(ctx, nil, backend, createOpts, buildOpts, project, nil)
+	require.NoError(t, err)
+}
+
+func sampleProject() *types.Project {
+	return &types.Project{
+		Name: "test",
+		Services: types.Services{
+			"svc": {
+				Name: "svc",
+				Build: &types.BuildConfig{
+					Context: ".",
+				},
+			},
+		},
+	}
+}
+
+func defaultCreateOptions(includeBuild bool) api.CreateOptions {
+	var build *api.BuildOptions
+	if includeBuild {
+		bo := defaultBuildOptions()
+		build = &bo
+	}
+	return api.CreateOptions{
+		Build:                build,
+		Services:             nil,
+		RemoveOrphans:        false,
+		IgnoreOrphans:        false,
+		Recreate:             "diverged",
+		RecreateDependencies: "diverged",
+		Inherit:              true,
+		Timeout:              nil,
+		QuietPull:            false,
+	}
+}
+
+func defaultBuildOptions() api.BuildOptions {
+	return api.BuildOptions{
+		Args:     make(types.MappingWithEquals),
+		Progress: "auto",
+	}
+}
+
+// deepEqual returns a nice diff on failure vs gomock.Eq when used
+// on structs.
+func deepEqual(x interface{}) gomock.Matcher {
+	return gomock.GotFormatterAdapter(
+		gomock.GotFormatterFunc(func(got interface{}) string {
+			return cmp.Diff(x, got)
+		}),
+		gomock.Eq(x),
+	)
+}
+
+func spewAdapter(m gomock.Matcher) gomock.Matcher {
+	return gomock.GotFormatterAdapter(
+		gomock.GotFormatterFunc(func(got interface{}) string {
+			return spew.Sdump(got)
+		}),
+		m,
+	)
+}
+
+type withPullPolicy struct {
+	policy string
+}
+
+func pullPolicy(policy string) gomock.Matcher {
+	return spewAdapter(withPullPolicy{policy: policy})
+}
+
+func (w withPullPolicy) Matches(x interface{}) bool {
+	proj, ok := x.(*types.Project)
+	if !ok || proj == nil || len(proj.Services) == 0 {
+		return false
+	}
+
+	for _, svc := range proj.Services {
+		if svc.PullPolicy != w.policy {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (w withPullPolicy) String() string {
+	return fmt.Sprintf("has pull policy %q for all services", w.policy)
+}

cmd/compose/down.go

@@ -22,6 +22,7 @@ import (
 	"os"
 	"time"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/utils"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -39,7 +40,7 @@ type downOptions struct {
 	images        string
 }
 
-func downCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func downCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := downOptions{
 		ProjectOptions: p,
 	}
@@ -56,7 +57,7 @@ func downCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runDown(ctx, backend, opts, args)
+			return runDown(ctx, dockerCli, backend, opts, args)
 		}),
 		ValidArgsFunction: noCompletion(),
 	}
@@ -76,8 +77,8 @@ func downCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return downCmd
 }
 
-func runDown(ctx context.Context, backend api.Service, opts downOptions, services []string) error {
-	project, name, err := opts.projectOrName()
+func runDown(ctx context.Context, dockerCli command.Cli, backend api.Service, opts downOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/events.go

@@ -21,6 +21,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 
 	"github.com/spf13/cobra"
@@ -31,7 +32,7 @@ type eventsOpts struct {
 	json bool
 }
 
-func eventsCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func eventsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := eventsOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -41,17 +42,17 @@ func eventsCommand(p *ProjectOptions, streams api.Streams, backend api.Service)
 		Use:   "events [OPTIONS] [SERVICE...]",
 		Short: "Receive real time events from containers.",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runEvents(ctx, streams, backend, opts, args)
+			return runEvents(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 
 	cmd.Flags().BoolVar(&opts.json, "json", false, "Output events as a stream of json objects")
 	return cmd
 }
 
-func runEvents(ctx context.Context, streams api.Streams, backend api.Service, opts eventsOpts, services []string) error {
-	name, err := opts.toProjectName()
+func runEvents(ctx context.Context, dockerCli command.Cli, backend api.Service, opts eventsOpts, services []string) error {
+	name, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}
@@ -71,9 +72,9 @@ func runEvents(ctx context.Context, streams api.Streams, backend api.Service, op
 				if err != nil {
 					return err
 				}
-				fmt.Fprintln(streams.Out(), string(marshal))
+				fmt.Fprintln(dockerCli.Out(), string(marshal))
 			} else {
-				fmt.Fprintln(streams.Out(), event)
+				fmt.Fprintln(dockerCli.Out(), event)
 			}
 			return nil
 		},

cmd/compose/exec.go

@@ -19,8 +19,9 @@ package compose
 import (
 	"context"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
@@ -42,7 +43,7 @@ type execOpts struct {
 	interactive bool
 }
 
-func execCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := execOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -58,9 +59,9 @@ func execCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runExec(ctx, backend, opts)
+			return runExec(ctx, dockerCli, backend, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 
 	runCmd.Flags().BoolVarP(&opts.detach, "detach", "d", false, "Detached mode: Run command in the background.")
@@ -68,7 +69,7 @@ func execCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 	runCmd.Flags().IntVar(&opts.index, "index", 0, "index of the container if service has multiple replicas")
 	runCmd.Flags().BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the process.")
 	runCmd.Flags().StringVarP(&opts.user, "user", "u", "", "Run the command as this user.")
-	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", !streams.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
+	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
 	runCmd.Flags().StringVarP(&opts.workingDir, "workdir", "w", "", "Path to workdir directory for this command.")
 
 	runCmd.Flags().BoolVarP(&opts.interactive, "interactive", "i", true, "Keep STDIN open even if not attached.")
@@ -80,8 +81,8 @@ func execCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 	return runCmd
 }
 
-func runExec(ctx context.Context, backend api.Service, opts execOpts) error {
-	projectName, err := opts.toProjectName()
+func runExec(ctx context.Context, dockerCli command.Cli, backend api.Service, opts execOpts) error {
+	projectName, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}

cmd/compose/images.go

@@ -23,6 +23,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/pkg/stringid"
 	"github.com/docker/go-units"
 	"github.com/spf13/cobra"
@@ -38,7 +39,7 @@ type imageOptions struct {
 	Format string
 }
 
-func imagesCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func imagesCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := imageOptions{
 		ProjectOptions: p,
 	}
@@ -46,17 +47,17 @@ func imagesCommand(p *ProjectOptions, streams api.Streams, backend api.Service)
 		Use:   "images [OPTIONS] [SERVICE...]",
 		Short: "List images used by the created containers",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runImages(ctx, streams, backend, opts, args)
+			return runImages(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	imgCmd.Flags().StringVar(&opts.Format, "format", "table", "Format the output. Values: [table | json].")
 	imgCmd.Flags().BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs")
 	return imgCmd
 }
 
-func runImages(ctx context.Context, streams api.Streams, backend api.Service, opts imageOptions, services []string) error {
-	projectName, err := opts.toProjectName()
+func runImages(ctx context.Context, dockerCli command.Cli, backend api.Service, opts imageOptions, services []string) error {
+	projectName, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}
@@ -80,7 +81,7 @@ func runImages(ctx context.Context, streams api.Streams, backend api.Service, op
 			}
 		}
 		for _, img := range ids {
-			fmt.Fprintln(streams.Out(), img)
+			fmt.Fprintln(dockerCli.Out(), img)
 		}
 		return nil
 	}
@@ -89,7 +90,7 @@ func runImages(ctx context.Context, streams api.Streams, backend api.Service, op
 		return images[i].ContainerName < images[j].ContainerName
 	})
 
-	return formatter.Print(images, opts.Format, streams.Out(),
+	return formatter.Print(images, opts.Format, dockerCli.Out(),
 		func(w io.Writer) {
 			for _, img := range images {
 				id := stringid.TruncateID(img.ID)

cmd/compose/kill.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"os"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -32,7 +33,7 @@ type killOptions struct {
 	signal        string
 }
 
-func killCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func killCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := killOptions{
 		ProjectOptions: p,
 	}
@@ -40,9 +41,9 @@ func killCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Use:   "kill [OPTIONS] [SERVICE...]",
 		Short: "Force stop service containers.",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runKill(ctx, backend, opts, args)
+			return runKill(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 
 	flags := cmd.Flags()
@@ -53,8 +54,8 @@ func killCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
-func runKill(ctx context.Context, backend api.Service, opts killOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runKill(ctx context.Context, dockerCli command.Cli, backend api.Service, opts killOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/list.go

@@ -22,6 +22,7 @@ import (
 	"io"
 	"strings"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/cmd/formatter"
 
 	"github.com/docker/cli/opts"
@@ -37,13 +38,13 @@ type lsOptions struct {
 	Filter opts.FilterOpt
 }
 
-func listCommand(streams api.Streams, backend api.Service) *cobra.Command {
+func listCommand(dockerCli command.Cli, backend api.Service) *cobra.Command {
 	lsOpts := lsOptions{Filter: opts.NewFilterOpt()}
 	lsCmd := &cobra.Command{
 		Use:   "ls [OPTIONS]",
 		Short: "List running compose projects",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runList(ctx, streams, backend, lsOpts)
+			return runList(ctx, dockerCli, backend, lsOpts)
 		}),
 		Args:              cobra.NoArgs,
 		ValidArgsFunction: noCompletion(),
@@ -60,7 +61,7 @@ var acceptedListFilters = map[string]bool{
 	"name": true,
 }
 
-func runList(ctx context.Context, streams api.Streams, backend api.Service, lsOpts lsOptions) error {
+func runList(ctx context.Context, dockerCli command.Cli, backend api.Service, lsOpts lsOptions) error {
 	filters := lsOpts.Filter.Value()
 	err := filters.Validate(acceptedListFilters)
 	if err != nil {
@@ -71,12 +72,6 @@ func runList(ctx context.Context, streams api.Streams, backend api.Service, lsOp
 	if err != nil {
 		return err
 	}
-	if lsOpts.Quiet {
-		for _, s := range stackList {
-			fmt.Fprintln(streams.Out(), s.Name)
-		}
-		return nil
-	}
 
 	if filters.Len() > 0 {
 		var filtered []api.Stack
@@ -89,8 +84,15 @@ func runList(ctx context.Context, streams api.Streams, backend api.Service, lsOp
 		stackList = filtered
 	}
 
+	if lsOpts.Quiet {
+		for _, s := range stackList {
+			fmt.Fprintln(dockerCli.Out(), s.Name)
+		}
+		return nil
+	}
+
 	view := viewFromStackList(stackList)
-	return formatter.Print(view, lsOpts.Format, streams.Out(), func(w io.Writer) {
+	return formatter.Print(view, lsOpts.Format, dockerCli.Out(), func(w io.Writer) {
 		for _, stack := range view {
 			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\n", stack.Name, stack.Status, stack.ConfigFiles)
 		}

cmd/compose/logs.go

@@ -18,7 +18,9 @@ package compose
 
 import (
 	"context"
+	"errors"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/cmd/formatter"
@@ -29,6 +31,7 @@ type logsOptions struct {
 	*ProjectOptions
 	composeOptions
 	follow     bool
+	index      int
 	tail       string
 	since      string
 	until      string
@@ -37,7 +40,7 @@ type logsOptions struct {
 	timestamps bool
 }
 
-func logsCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func logsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := logsOptions{
 		ProjectOptions: p,
 	}
@@ -45,12 +48,19 @@ func logsCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 		Use:   "logs [OPTIONS] [SERVICE...]",
 		Short: "View output from containers",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runLogs(ctx, streams, backend, opts, args)
+			return runLogs(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			if opts.index > 0 && len(args) != 1 {
+				return errors.New("--index requires one service to be selected")
+			}
+			return nil
+		},
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := logsCmd.Flags()
 	flags.BoolVarP(&opts.follow, "follow", "f", false, "Follow log output.")
+	flags.IntVar(&opts.index, "index", 0, "index of the container if service has multiple replicas")
 	flags.StringVar(&opts.since, "since", "", "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
 	flags.StringVar(&opts.until, "until", "", "Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
 	flags.BoolVar(&opts.noColor, "no-color", false, "Produce monochrome output.")
@@ -60,16 +70,17 @@ func logsCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 	return logsCmd
 }
 
-func runLogs(ctx context.Context, streams api.Streams, backend api.Service, opts logsOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runLogs(ctx context.Context, dockerCli command.Cli, backend api.Service, opts logsOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}
-	consumer := formatter.NewLogConsumer(ctx, streams.Out(), streams.Err(), !opts.noColor, !opts.noPrefix, false)
+	consumer := formatter.NewLogConsumer(ctx, dockerCli.Out(), dockerCli.Err(), !opts.noColor, !opts.noPrefix, false)
 	return backend.Logs(ctx, name, consumer, api.LogOptions{
 		Project:    project,
 		Services:   services,
 		Follow:     opts.follow,
+		Index:      opts.index,
 		Tail:       opts.tail,
 		Since:      opts.since,
 		Until:      opts.until,

cmd/compose/options.go

@@ -0,0 +1,74 @@
+/*
+   Copyright 2023 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"fmt"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/compose/v2/pkg/utils"
+)
+
+func applyPlatforms(project *types.Project, buildForSinglePlatform bool) error {
+	defaultPlatform := project.Environment["DOCKER_DEFAULT_PLATFORM"]
+	for name, service := range project.Services {
+		if service.Build == nil {
+			continue
+		}
+
+		// default platform only applies if the service doesn't specify
+		if defaultPlatform != "" && service.Platform == "" {
+			if len(service.Build.Platforms) > 0 && !utils.StringContains(service.Build.Platforms, defaultPlatform) {
+				return fmt.Errorf("service %q build.platforms does not support value set by DOCKER_DEFAULT_PLATFORM: %s", name, defaultPlatform)
+			}
+			service.Platform = defaultPlatform
+		}
+
+		if service.Platform != "" {
+			if len(service.Build.Platforms) > 0 {
+				if !utils.StringContains(service.Build.Platforms, service.Platform) {
+					return fmt.Errorf("service %q build configuration does not support platform: %s", name, service.Platform)
+				}
+			}
+
+			if buildForSinglePlatform || len(service.Build.Platforms) == 0 {
+				// if we're building for a single platform, we want to build for the platform we'll use to run the image
+				// similarly, if no build platforms were explicitly specified, it makes sense to build for the platform
+				// the image is designed for rather than allowing the builder to infer the platform
+				service.Build.Platforms = []string{service.Platform}
+			}
+		}
+
+		// services can specify that they should be built for multiple platforms, which can be used
+		// with `docker compose build` to produce a multi-arch image
+		// other cases, such as `up` and `run`, need a single architecture to actually run
+		// if there is only a single platform present (which might have been inferred
+		// from service.Platform above), it will be used, even if it requires emulation.
+		// if there's more than one platform, then the list is cleared so that the builder
+		// can decide.
+		// TODO(milas): there's no validation that the platform the builder will pick is actually one
+		// 	of the supported platforms from the build definition
+		// 	e.g. `build.platforms: [linux/arm64, linux/amd64]` on a `linux/ppc64` machine would build
+		// 	for `linux/ppc64` instead of returning an error that it's not a valid platform for the service.
+		if buildForSinglePlatform && len(service.Build.Platforms) > 1 {
+			// empty indicates that the builder gets to decide
+			service.Build.Platforms = nil
+		}
+		project.Services[name] = service
+	}
+	return nil
+}

cmd/compose/options_test.go

@@ -0,0 +1,130 @@
+/*
+   Copyright 2023 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"testing"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestApplyPlatforms_InferFromRuntime(t *testing.T) {
+	makeProject := func() *types.Project {
+		return &types.Project{
+			Services: types.Services{
+				"test": {
+					Name:  "test",
+					Image: "foo",
+					Build: &types.BuildConfig{
+						Context: ".",
+						Platforms: []string{
+							"linux/amd64",
+							"linux/arm64",
+							"alice/32",
+						},
+					},
+					Platform: "alice/32",
+				},
+			},
+		}
+	}
+
+	t.Run("SinglePlatform", func(t *testing.T) {
+		project := makeProject()
+		require.NoError(t, applyPlatforms(project, true))
+		require.EqualValues(t, []string{"alice/32"}, project.Services["test"].Build.Platforms)
+	})
+
+	t.Run("MultiPlatform", func(t *testing.T) {
+		project := makeProject()
+		require.NoError(t, applyPlatforms(project, false))
+		require.EqualValues(t, []string{"linux/amd64", "linux/arm64", "alice/32"},
+			project.Services["test"].Build.Platforms)
+	})
+}
+
+func TestApplyPlatforms_DockerDefaultPlatform(t *testing.T) {
+	makeProject := func() *types.Project {
+		return &types.Project{
+			Environment: map[string]string{
+				"DOCKER_DEFAULT_PLATFORM": "linux/amd64",
+			},
+			Services: types.Services{
+				"test": {
+					Name:  "test",
+					Image: "foo",
+					Build: &types.BuildConfig{
+						Context: ".",
+						Platforms: []string{
+							"linux/amd64",
+							"linux/arm64",
+						},
+					},
+				},
+			},
+		}
+	}
+
+	t.Run("SinglePlatform", func(t *testing.T) {
+		project := makeProject()
+		require.NoError(t, applyPlatforms(project, true))
+		require.EqualValues(t, []string{"linux/amd64"}, project.Services["test"].Build.Platforms)
+	})
+
+	t.Run("MultiPlatform", func(t *testing.T) {
+		project := makeProject()
+		require.NoError(t, applyPlatforms(project, false))
+		require.EqualValues(t, []string{"linux/amd64", "linux/arm64"},
+			project.Services["test"].Build.Platforms)
+	})
+}
+
+func TestApplyPlatforms_UnsupportedPlatform(t *testing.T) {
+	makeProject := func() *types.Project {
+		return &types.Project{
+			Environment: map[string]string{
+				"DOCKER_DEFAULT_PLATFORM": "commodore/64",
+			},
+			Services: types.Services{
+				"test": {
+					Name:  "test",
+					Image: "foo",
+					Build: &types.BuildConfig{
+						Context: ".",
+						Platforms: []string{
+							"linux/amd64",
+							"linux/arm64",
+						},
+					},
+				},
+			},
+		}
+	}
+
+	t.Run("SinglePlatform", func(t *testing.T) {
+		project := makeProject()
+		require.EqualError(t, applyPlatforms(project, true),
+			`service "test" build.platforms does not support value set by DOCKER_DEFAULT_PLATFORM: commodore/64`)
+	})
+
+	t.Run("MultiPlatform", func(t *testing.T) {
+		project := makeProject()
+		require.EqualError(t, applyPlatforms(project, false),
+			`service "test" build.platforms does not support value set by DOCKER_DEFAULT_PLATFORM: commodore/64`)
+	})
+}

cmd/compose/pause.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -28,7 +29,7 @@ type pauseOptions struct {
 	*ProjectOptions
 }
 
-func pauseCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func pauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pauseOptions{
 		ProjectOptions: p,
 	}
@@ -36,15 +37,15 @@ func pauseCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Use:   "pause [SERVICE...]",
 		Short: "Pause services",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runPause(ctx, backend, opts, args)
+			return runPause(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	return cmd
 }
 
-func runPause(ctx context.Context, backend api.Service, opts pauseOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runPause(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pauseOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}
@@ -59,7 +60,7 @@ type unpauseOptions struct {
 	*ProjectOptions
 }
 
-func unpauseCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func unpauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := unpauseOptions{
 		ProjectOptions: p,
 	}
@@ -67,15 +68,15 @@ func unpauseCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Use:   "unpause [SERVICE...]",
 		Short: "Unpause services",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runUnPause(ctx, backend, opts, args)
+			return runUnPause(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	return cmd
 }
 
-func runUnPause(ctx context.Context, backend api.Service, opts unpauseOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runUnPause(ctx context.Context, dockerCli command.Cli, backend api.Service, opts unpauseOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/port.go

@@ -22,6 +22,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -34,7 +35,7 @@ type portOptions struct {
 	index    int
 }
 
-func portCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func portCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := portOptions{
 		ProjectOptions: p,
 	}
@@ -52,17 +53,17 @@ func portCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *c
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runPort(ctx, streams, backend, opts, args[0])
+			return runPort(ctx, dockerCli, backend, opts, args[0])
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	cmd.Flags().StringVar(&opts.protocol, "protocol", "tcp", "tcp or udp")
 	cmd.Flags().IntVar(&opts.index, "index", 0, "index of the container if service has multiple replicas")
 	return cmd
 }
 
-func runPort(ctx context.Context, streams api.Streams, backend api.Service, opts portOptions, service string) error {
-	projectName, err := opts.toProjectName()
+func runPort(ctx context.Context, dockerCli command.Cli, backend api.Service, opts portOptions, service string) error {
+	projectName, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}
@@ -74,6 +75,6 @@ func runPort(ctx context.Context, streams api.Streams, backend api.Service, opts
 		return err
 	}
 
-	fmt.Fprintf(streams.Out(), "%s:%d\n", ip, port)
+	fmt.Fprintf(dockerCli.Out(), "%s:%d\n", ip, port)
 	return nil
 }

cmd/compose/ps.go

@@ -18,23 +18,19 @@ package compose
 
 import (
 	"context"
+	"errors"
 	"fmt"
-	"io"
 	"sort"
-	"strconv"
 	"strings"
-	"time"
 
 	"github.com/docker/compose/v2/cmd/formatter"
-	"github.com/docker/compose/v2/pkg/utils"
-	"github.com/docker/docker/api/types"
-
-	formatter2 "github.com/docker/cli/cli/command/formatter"
-	"github.com/docker/go-units"
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/utils"
+
+	"github.com/docker/cli/cli/command"
+	cliformatter "github.com/docker/cli/cli/command/formatter"
+	cliflags "github.com/docker/cli/cli/flags"
+	"github.com/spf13/cobra"
 )
 
 type psOptions struct {
@@ -45,6 +41,8 @@ type psOptions struct {
 	Services bool
 	Filter   string
 	Status   []string
+	noTrunc  bool
+	Orphans  bool
 }
 
 func (p *psOptions) parseFilter() error {
@@ -66,7 +64,7 @@ func (p *psOptions) parseFilter() error {
 	return nil
 }
 
-func psCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func psCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := psOptions{
 		ProjectOptions: p,
 	}
@@ -77,32 +75,39 @@ func psCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cob
 			return opts.parseFilter()
 		},
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runPs(ctx, streams, backend, args, opts)
+			return runPs(ctx, dockerCli, backend, args, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := psCmd.Flags()
-	flags.StringVar(&opts.Format, "format", "table", "Format the output. Values: [table | json]")
+	flags.StringVar(&opts.Format, "format", "table", cliflags.FormatHelp)
 	flags.StringVar(&opts.Filter, "filter", "", "Filter services by a property (supported filters: status).")
 	flags.StringArrayVar(&opts.Status, "status", []string{}, "Filter services by status. Values: [paused | restarting | removing | running | dead | created | exited]")
 	flags.BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs")
 	flags.BoolVar(&opts.Services, "services", false, "Display services")
+	flags.BoolVar(&opts.Orphans, "orphans", true, "Include orphaned services (not declared by project)")
 	flags.BoolVarP(&opts.All, "all", "a", false, "Show all stopped containers (including those created by the run command)")
+	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Don't truncate output")
 	return psCmd
 }
 
-func runPs(ctx context.Context, streams api.Streams, backend api.Service, services []string, opts psOptions) error {
-	project, name, err := opts.projectOrName(services...)
+func runPs(ctx context.Context, dockerCli command.Cli, backend api.Service, services []string, opts psOptions) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}
 
-	if project != nil && len(services) > 0 {
+	if project != nil {
 		names := project.ServiceNames()
-		for _, service := range services {
-			if !utils.StringContains(names, service) {
-				return fmt.Errorf("no such service: %s", service)
+		if len(services) > 0 {
+			for _, service := range services {
+				if !utils.StringContains(names, service) {
+					return fmt.Errorf("no such service: %s", service)
+				}
 			}
+		} else if !opts.Orphans {
+			// until user asks to list orphaned services, we only include those declared in project
+			services = names
 		}
 	}
 
@@ -125,38 +130,33 @@ func runPs(ctx context.Context, streams api.Streams, backend api.Service, servic
 
 	if opts.Quiet {
 		for _, c := range containers {
-			fmt.Fprintln(streams.Out(), c.ID)
+			fmt.Fprintln(dockerCli.Out(), c.ID)
 		}
 		return nil
 	}
 
 	if opts.Services {
 		services := []string{}
-		for _, s := range containers {
-			if !utils.StringContains(services, s.Service) {
-				services = append(services, s.Service)
+		for _, c := range containers {
+			s := c.Service
+			if !utils.StringContains(services, s) {
+				services = append(services, s)
 			}
 		}
-		fmt.Fprintln(streams.Out(), strings.Join(services, "\n"))
+		fmt.Fprintln(dockerCli.Out(), strings.Join(services, "\n"))
 		return nil
 	}
 
-	return formatter.Print(containers, opts.Format, streams.Out(),
-		writer(containers),
-		"NAME", "IMAGE", "COMMAND", "SERVICE", "CREATED", "STATUS", "PORTS")
-}
-
-func writer(containers []api.ContainerSummary) func(w io.Writer) {
-	return func(w io.Writer) {
-		for _, container := range containers {
-			ports := displayablePorts(container)
-			createdAt := time.Unix(container.Created, 0)
-			created := units.HumanDuration(time.Now().UTC().Sub(createdAt)) + " ago"
-			status := container.Status
-			command := formatter2.Ellipsis(container.Command, 20)
-			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", container.Name, container.Image, strconv.Quote(command), container.Service, created, status, ports)
-		}
+	if opts.Format == "" {
+		opts.Format = dockerCli.ConfigFile().PsFormat
 	}
+
+	containerCtx := cliformatter.Context{
+		Output: dockerCli.Out(),
+		Format: formatter.NewContainerFormat(opts.Format, opts.Quiet, false),
+		Trunc:  !opts.noTrunc,
+	}
+	return formatter.ContainerWrite(containerCtx, containers)
 }
 
 func filterByStatus(containers []api.ContainerSummary, statuses []string) []api.ContainerSummary {
@@ -177,21 +177,3 @@ func hasStatus(c api.ContainerSummary, statuses []string) bool {
 	}
 	return false
 }
-
-func displayablePorts(c api.ContainerSummary) string {
-	if c.Publishers == nil {
-		return ""
-	}
-
-	ports := make([]types.Port, len(c.Publishers))
-	for i, pub := range c.Publishers {
-		ports[i] = types.Port{
-			IP:          pub.URL,
-			PrivatePort: uint16(pub.TargetPort),
-			PublicPort:  uint16(pub.PublishedPort),
-			Type:        pub.Protocol,
-		}
-	}
-
-	return formatter2.DisplayablePorts(ports)
-}

cmd/compose/ps_test.go

@@ -18,16 +18,16 @@ package compose
 
 import (
 	"context"
-	"io"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/cli/streams"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/mocks"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
 )
 
 func TestPsTable(t *testing.T) {
@@ -69,7 +69,11 @@ func TestPsTable(t *testing.T) {
 		}).AnyTimes()
 
 	opts := psOptions{ProjectOptions: &ProjectOptions{ProjectName: "test"}}
-	err = runPs(ctx, stream{out: streams.NewOut(f)}, backend, nil, opts)
+	stdout := streams.NewOut(f)
+	cli := mocks.NewMockCli(ctrl)
+	cli.EXPECT().Out().Return(stdout).AnyTimes()
+	cli.EXPECT().ConfigFile().Return(&configfile.ConfigFile{}).AnyTimes()
+	err = runPs(ctx, cli, backend, nil, opts)
 	assert.NoError(t, err)
 
 	_, err = f.Seek(0, 0)
@@ -80,21 +84,3 @@ func TestPsTable(t *testing.T) {
 
 	assert.Contains(t, string(output), "8080/tcp, 8443/tcp")
 }
-
-type stream struct {
-	out *streams.Out
-	err io.Writer
-	in  *streams.In
-}
-
-func (s stream) Out() *streams.Out {
-	return s.out
-}
-
-func (s stream) Err() io.Writer {
-	return s.err
-}
-
-func (s stream) In() *streams.In {
-	return s.in
-}

cmd/compose/publish.go

@@ -0,0 +1,62 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+
+	"github.com/docker/cli/cli/command"
+	"github.com/spf13/cobra"
+
+	"github.com/docker/compose/v2/pkg/api"
+)
+
+type publishOptions struct {
+	*ProjectOptions
+	resolveImageDigests bool
+	ociVersion          string
+}
+
+func publishCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+	opts := publishOptions{
+		ProjectOptions: p,
+	}
+	cmd := &cobra.Command{
+		Use:   "publish [OPTIONS] [REPOSITORY]",
+		Short: "Publish compose application",
+		RunE: Adapt(func(ctx context.Context, args []string) error {
+			return runPublish(ctx, dockerCli, backend, opts, args[0])
+		}),
+		Args: cobra.ExactArgs(1),
+	}
+	flags := cmd.Flags()
+	flags.BoolVar(&opts.resolveImageDigests, "resolve-image-digests", false, "Pin image tags to digests.")
+	flags.StringVar(&opts.ociVersion, "oci-version", "", "OCI Image/Artifact specification version (automatically determined by default)")
+	return cmd
+}
+
+func runPublish(ctx context.Context, dockerCli command.Cli, backend api.Service, opts publishOptions, repository string) error {
+	project, err := opts.ToProject(dockerCli, nil)
+	if err != nil {
+		return err
+	}
+
+	return backend.Publish(ctx, project, repository, api.PublishOptions{
+		ResolveImageDigests: opts.resolveImageDigests,
+		OCIVersion:          api.OCIVersion(opts.ociVersion),
+	})
+}

cmd/compose/pull.go

@@ -21,7 +21,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/morikuni/aec"
 	"github.com/spf13/cobra"
 
@@ -37,9 +38,10 @@ type pullOptions struct {
 	includeDeps        bool
 	ignorePullFailures bool
 	noBuildable        bool
+	policy             string
 }
 
-func pullCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func pullCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pullOptions{
 		ProjectOptions: p,
 	}
@@ -53,9 +55,9 @@ func pullCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runPull(ctx, backend, opts, args)
+			return runPull(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Pull without printing progress information.")
@@ -66,20 +68,40 @@ func pullCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	flags.MarkHidden("no-parallel") //nolint:errcheck
 	cmd.Flags().BoolVar(&opts.ignorePullFailures, "ignore-pull-failures", false, "Pull what it can and ignores images with pull failures.")
 	cmd.Flags().BoolVar(&opts.noBuildable, "ignore-buildable", false, "Ignore images that can be built.")
+	cmd.Flags().StringVar(&opts.policy, "policy", "", `Apply pull policy ("missing"|"always").`)
 	return cmd
 }
 
-func runPull(ctx context.Context, backend api.Service, opts pullOptions, services []string) error {
-	project, err := opts.ToProject(services)
+func (opts pullOptions) apply(project *types.Project, services []string) (*types.Project, error) {
+	if !opts.includeDeps {
+		var err error
+		project, err = project.WithSelectedServices(services, types.IgnoreDependencies)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if opts.policy != "" {
+		for i, service := range project.Services {
+			if service.Image == "" {
+				continue
+			}
+			service.PullPolicy = opts.policy
+			project.Services[i] = service
+		}
+	}
+	return project, nil
+}
+
+func runPull(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pullOptions, services []string) error {
+	project, err := opts.ToProject(dockerCli, services)
 	if err != nil {
 		return err
 	}
 
-	if !opts.includeDeps {
-		err := project.ForServices(services, types.IgnoreDependencies)
-		if err != nil {
-			return err
-		}
+	project, err = opts.apply(project, services)
+	if err != nil {
+		return err
 	}
 
 	return backend.Pull(ctx, project, api.PullOptions{

cmd/compose/pullOptions_test.go

@@ -0,0 +1,57 @@
+/*
+   Copyright 2023 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"testing"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"gotest.tools/v3/assert"
+)
+
+func TestApplyPullOptions(t *testing.T) {
+	project := &types.Project{
+		Services: types.Services{
+			"must-build": {
+				Name: "must-build",
+				// No image, local build only
+				Build: &types.BuildConfig{
+					Context: ".",
+				},
+			},
+			"has-build": {
+				Name:  "has-build",
+				Image: "registry.example.com/myservice",
+				Build: &types.BuildConfig{
+					Context: ".",
+				},
+			},
+			"must-pull": {
+				Name:  "must-pull",
+				Image: "registry.example.com/another-service",
+			},
+		},
+	}
+	project, err := pullOptions{
+		policy: types.PullPolicyMissing,
+	}.apply(project, nil)
+	assert.NilError(t, err)
+
+	assert.Equal(t, project.Services["must-build"].PullPolicy, "") // still default
+	assert.Equal(t, project.Services["has-build"].PullPolicy, types.PullPolicyMissing)
+	assert.Equal(t, project.Services["must-pull"].PullPolicy, types.PullPolicyMissing)
+}

cmd/compose/push.go

@@ -19,7 +19,8 @@ package compose
 import (
 	"context"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -33,7 +34,7 @@ type pushOptions struct {
 	Quiet          bool
 }
 
-func pushCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func pushCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pushOptions{
 		ProjectOptions: p,
 	}
@@ -41,9 +42,9 @@ func pushCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Use:   "push [OPTIONS] [SERVICE...]",
 		Short: "Push service images",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runPush(ctx, backend, opts, args)
+			return runPush(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	pushCmd.Flags().BoolVar(&opts.Ignorefailures, "ignore-push-failures", false, "Push what it can and ignores images with push failures")
 	pushCmd.Flags().BoolVar(&opts.IncludeDeps, "include-deps", false, "Also push images of services declared as dependencies")
@@ -52,14 +53,14 @@ func pushCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return pushCmd
 }
 
-func runPush(ctx context.Context, backend api.Service, opts pushOptions, services []string) error {
-	project, err := opts.ToProject(services)
+func runPush(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pushOptions, services []string) error {
+	project, err := opts.ToProject(dockerCli, services)
 	if err != nil {
 		return err
 	}
 
 	if !opts.IncludeDeps {
-		err := project.ForServices(services, types.IgnoreDependencies)
+		project, err = project.WithSelectedServices(services, types.IgnoreDependencies)
 		if err != nil {
 			return err
 		}

cmd/compose/remove.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -30,7 +31,7 @@ type removeOptions struct {
 	volumes bool
 }
 
-func removeCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func removeCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := removeOptions{
 		ProjectOptions: p,
 	}
@@ -44,9 +45,9 @@ can override this with -v. To list all volumes, use "docker volume ls".
 
 Any data which is not in a volume will be lost.`,
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runRemove(ctx, backend, opts, args)
+			return runRemove(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	f := cmd.Flags()
 	f.BoolVarP(&opts.force, "force", "f", false, "Don't ask to confirm removal")
@@ -58,8 +59,8 @@ Any data which is not in a volume will be lost.`,
 	return cmd
 }
 
-func runRemove(ctx context.Context, backend api.Service, opts removeOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runRemove(ctx context.Context, dockerCli command.Cli, backend api.Service, opts removeOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/restart.go

@@ -20,7 +20,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -33,7 +33,7 @@ type restartOptions struct {
 	noDeps      bool
 }
 
-func restartCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func restartCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := restartOptions{
 		ProjectOptions: p,
 	}
@@ -44,9 +44,9 @@ func restartCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			opts.timeChanged = cmd.Flags().Changed("timeout")
 		},
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runRestart(ctx, backend, opts, args)
+			return runRestart(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := restartCmd.Flags()
 	flags.IntVarP(&opts.timeout, "timeout", "t", 0, "Specify a shutdown timeout in seconds")
@@ -55,28 +55,29 @@ func restartCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return restartCmd
 }
 
-func runRestart(ctx context.Context, backend api.Service, opts restartOptions, services []string) error {
-	project, name, err := opts.projectOrName()
+func runRestart(ctx context.Context, dockerCli command.Cli, backend api.Service, opts restartOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli)
 	if err != nil {
 		return err
 	}
 
+	if project != nil && len(services) > 0 {
+		project, err = project.WithServicesEnabled(services...)
+		if err != nil {
+			return err
+		}
+	}
+
 	var timeout *time.Duration
 	if opts.timeChanged {
 		timeoutValue := time.Duration(opts.timeout) * time.Second
 		timeout = &timeoutValue
 	}
 
-	if opts.noDeps {
-		err := project.ForServices(services, types.IgnoreDependencies)
-		if err != nil {
-			return err
-		}
-	}
-
 	return backend.Restart(ctx, name, api.RestartOptions{
 		Timeout:  timeout,
 		Services: services,
 		Project:  project,
+		NoDeps:   opts.noDeps,
 	})
 }

cmd/compose/run.go

@@ -21,9 +21,13 @@ import (
 	"fmt"
 	"strings"
 
-	cgo "github.com/compose-spec/compose-go/cli"
-	"github.com/compose-spec/compose-go/loader"
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/format"
+	xprogress "github.com/moby/buildkit/util/progress/progressui"
+	"github.com/sirupsen/logrus"
+
+	cgo "github.com/compose-spec/compose-go/v2/cli"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/opts"
 	"github.com/mattn/go-shellwords"
 	"github.com/spf13/cobra"
@@ -62,54 +66,56 @@ type runOptions struct {
 	quietPull     bool
 }
 
-func (options runOptions) apply(project *types.Project) error {
+func (options runOptions) apply(project *types.Project) (*types.Project, error) {
 	if options.noDeps {
-		err := project.ForServices([]string{options.Service}, types.IgnoreDependencies)
+		var err error
+		project, err = project.WithSelectedServices([]string{options.Service}, types.IgnoreDependencies)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	target, err := project.GetService(options.Service)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	target.Tty = !options.noTty
 	target.StdinOpen = options.interactive
+
+	// --service-ports and --publish are incompatible
 	if !options.servicePorts {
-		target.Ports = []types.ServicePortConfig{}
-	}
-	if len(options.publish) > 0 {
+		if len(target.Ports) > 0 {
+			logrus.Debug("Running service without ports exposed as --service-ports=false")
+		}
 		target.Ports = []types.ServicePortConfig{}
 		for _, p := range options.publish {
 			config, err := types.ParsePortConfig(p)
 			if err != nil {
-				return err
+				return nil, err
 			}
 			target.Ports = append(target.Ports, config...)
 		}
 	}
-	if len(options.volumes) > 0 {
-		for _, v := range options.volumes {
-			volume, err := loader.ParseVolume(v)
-			if err != nil {
-				return err
-			}
-			target.Volumes = append(target.Volumes, volume)
+
+	for _, v := range options.volumes {
+		volume, err := format.ParseVolume(v)
+		if err != nil {
+			return nil, err
 		}
+		target.Volumes = append(target.Volumes, volume)
 	}
 
-	for i, s := range project.Services {
-		if s.Name == options.Service {
-			project.Services[i] = target
+	for name := range project.Services {
+		if name == options.Service {
+			project.Services[name] = target
 			break
 		}
 	}
-	return nil
+	return project, nil
 }
 
-func runCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	options := runOptions{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -118,6 +124,9 @@ func runCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *co
 		capDrop: opts.NewListOpts(nil),
 	}
 	createOpts := createOptions{}
+	buildOpts := buildOptions{
+		ProjectOptions: p,
+	}
 	cmd := &cobra.Command{
 		Use:   "run [OPTIONS] SERVICE [COMMAND] [ARGS...]",
 		Short: "Run a one-off command on a service.",
@@ -147,22 +156,26 @@ func runCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *co
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			project, err := p.ToProject([]string{options.Service}, cgo.WithResolvedPaths(true), cgo.WithDiscardEnvFile)
+			project, err := p.ToProject(dockerCli, []string{options.Service}, cgo.WithResolvedPaths(true), cgo.WithDiscardEnvFile)
 			if err != nil {
 				return err
 			}
 
+			if createOpts.quietPull {
+				buildOpts.Progress = string(xprogress.QuietMode)
+			}
+
 			options.ignoreOrphans = utils.StringToBool(project.Environment[ComposeIgnoreOrphans])
-			return runRun(ctx, backend, project, options, createOpts, streams)
+			return runRun(ctx, backend, project, options, createOpts, buildOpts, dockerCli)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVarP(&options.Detach, "detach", "d", false, "Run container in background and print container ID")
 	flags.StringArrayVarP(&options.environment, "env", "e", []string{}, "Set environment variables")
 	flags.StringArrayVarP(&options.labels, "label", "l", []string{}, "Add or override a label")
 	flags.BoolVar(&options.Remove, "rm", false, "Automatically remove the container when it exits")
-	flags.BoolVarP(&options.noTty, "no-TTY", "T", !streams.Out().IsTerminal(), "Disable pseudo-TTY allocation (default: auto-detected).")
+	flags.BoolVarP(&options.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation (default: auto-detected).")
 	flags.StringVar(&options.name, "name", "", "Assign a name to the container")
 	flags.StringVarP(&options.user, "user", "u", "", "Run as specified username or uid")
 	flags.StringVarP(&options.workdir, "workdir", "w", "", "Working directory inside the container")
@@ -173,7 +186,7 @@ func runCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *co
 	flags.StringArrayVarP(&options.volumes, "volume", "v", []string{}, "Bind mount a volume.")
 	flags.StringArrayVarP(&options.publish, "publish", "p", []string{}, "Publish a container's port(s) to the host.")
 	flags.BoolVar(&options.useAliases, "use-aliases", false, "Use the service's network useAliases in the network(s) the container connects to.")
-	flags.BoolVar(&options.servicePorts, "service-ports", false, "Run command with the service's ports enabled and mapped to the host.")
+	flags.BoolVarP(&options.servicePorts, "service-ports", "P", false, "Run command with all service's ports enabled and mapped to the host.")
 	flags.BoolVar(&options.quietPull, "quiet-pull", false, "Pull without printing progress information.")
 	flags.BoolVar(&createOpts.Build, "build", false, "Build image before starting container.")
 	flags.BoolVar(&createOpts.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file.")
@@ -197,8 +210,8 @@ func normalizeRunFlags(f *pflag.FlagSet, name string) pflag.NormalizedName {
 	return pflag.NormalizedName(name)
 }
 
-func runRun(ctx context.Context, backend api.Service, project *types.Project, options runOptions, createOpts createOptions, streams api.Streams) error {
-	err := options.apply(project)
+func runRun(ctx context.Context, backend api.Service, project *types.Project, options runOptions, createOpts createOptions, buildOpts buildOptions, dockerCli command.Cli) error {
+	project, err := options.apply(project)
 	if err != nil {
 		return err
 	}
@@ -209,8 +222,17 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 	}
 
 	err = progress.Run(ctx, func(ctx context.Context) error {
-		return startDependencies(ctx, backend, *project, options.Service, options.ignoreOrphans)
-	}, streams.Err())
+		var buildForDeps *api.BuildOptions
+		if !createOpts.noBuild {
+			// allow dependencies needing build to be implicitly selected
+			bo, err := buildOpts.toAPIBuildOptions(nil)
+			if err != nil {
+				return err
+			}
+			buildForDeps = &bo
+		}
+		return startDependencies(ctx, backend, *project, buildForDeps, options.Service, options.ignoreOrphans)
+	}, dockerCli.Err())
 	if err != nil {
 		return err
 	}
@@ -224,8 +246,20 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 		labels[parts[0]] = parts[1]
 	}
 
+	var buildForRun *api.BuildOptions
+	if !createOpts.noBuild {
+		// dependencies have already been started above, so only the service
+		// being run might need to be built at this point
+		bo, err := buildOpts.toAPIBuildOptions([]string{options.Service})
+		if err != nil {
+			return err
+		}
+		buildForRun = &bo
+	}
+
 	// start container and attach to container streams
 	runOpts := api.RunOptions{
+		Build:             buildForRun,
 		Name:              options.name,
 		Service:           options.Service,
 		Command:           options.Command,
@@ -246,10 +280,10 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 		QuietPull:         options.quietPull,
 	}
 
-	for i, service := range project.Services {
-		if service.Name == options.Service {
+	for name, service := range project.Services {
+		if name == options.Service {
 			service.StdinOpen = options.interactive
-			project.Services[i] = service
+			project.Services[name] = service
 		}
 	}
 
@@ -264,20 +298,21 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 	return err
 }
 
-func startDependencies(ctx context.Context, backend api.Service, project types.Project, requestedServiceName string, ignoreOrphans bool) error {
+func startDependencies(ctx context.Context, backend api.Service, project types.Project, buildOpts *api.BuildOptions, requestedServiceName string, ignoreOrphans bool) error {
 	dependencies := types.Services{}
 	var requestedService types.ServiceConfig
-	for _, service := range project.Services {
-		if service.Name != requestedServiceName {
-			dependencies = append(dependencies, service)
+	for name, service := range project.Services {
+		if name != requestedServiceName {
+			dependencies[name] = service
 		} else {
 			requestedService = service
 		}
 	}
 
 	project.Services = dependencies
-	project.DisabledServices = append(project.DisabledServices, requestedService)
+	project.DisabledServices[requestedServiceName] = requestedService
 	err := backend.Create(ctx, &project, api.CreateOptions{
+		Build:         buildOpts,
 		IgnoreOrphans: ignoreOrphans,
 	})
 	if err != nil {

cmd/compose/scale.go

@@ -0,0 +1,102 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/docker/cli/cli/command"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"golang.org/x/exp/maps"
+
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/spf13/cobra"
+)
+
+type scaleOptions struct {
+	*ProjectOptions
+	noDeps bool
+}
+
+func scaleCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+	opts := scaleOptions{
+		ProjectOptions: p,
+	}
+	scaleCmd := &cobra.Command{
+		Use:   "scale [SERVICE=REPLICAS...]",
+		Short: "Scale services ",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: Adapt(func(ctx context.Context, args []string) error {
+			serviceTuples, err := parseServicesReplicasArgs(args)
+			if err != nil {
+				return err
+			}
+			return runScale(ctx, dockerCli, backend, opts, serviceTuples)
+		}),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
+	}
+	flags := scaleCmd.Flags()
+	flags.BoolVar(&opts.noDeps, "no-deps", false, "Don't start linked services.")
+
+	return scaleCmd
+}
+
+func runScale(ctx context.Context, dockerCli command.Cli, backend api.Service, opts scaleOptions, serviceReplicaTuples map[string]int) error {
+	services := maps.Keys(serviceReplicaTuples)
+	project, err := opts.ToProject(dockerCli, services)
+	if err != nil {
+		return err
+	}
+
+	if opts.noDeps {
+		if project, err = project.WithSelectedServices(services, types.IgnoreDependencies); err != nil {
+			return err
+		}
+	}
+
+	for key, value := range serviceReplicaTuples {
+		service, err := project.GetService(key)
+		if err != nil {
+			return err
+		}
+		service.SetScale(value)
+		project.Services[key] = service
+	}
+
+	return backend.Scale(ctx, project, api.ScaleOptions{Services: services})
+}
+
+func parseServicesReplicasArgs(args []string) (map[string]int, error) {
+	serviceReplicaTuples := map[string]int{}
+	for _, arg := range args {
+		key, val, ok := strings.Cut(arg, "=")
+		if !ok || key == "" || val == "" {
+			return nil, fmt.Errorf("invalid scale specifier: %s", arg)
+		}
+		intValue, err := strconv.Atoi(val)
+
+		if err != nil {
+			return nil, fmt.Errorf("invalid scale specifier: can't parse replica value as int: %v", arg)
+		}
+		serviceReplicaTuples[key] = intValue
+	}
+	return serviceReplicaTuples, nil
+}

cmd/compose/start.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -27,7 +28,7 @@ type startOptions struct {
 	*ProjectOptions
 }
 
-func startCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func startCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := startOptions{
 		ProjectOptions: p,
 	}
@@ -35,15 +36,15 @@ func startCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Use:   "start [SERVICE...]",
 		Short: "Start services",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runStart(ctx, backend, opts, args)
+			return runStart(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	return startCmd
 }
 
-func runStart(ctx context.Context, backend api.Service, opts startOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runStart(ctx context.Context, dockerCli command.Cli, backend api.Service, opts startOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/stats.go

@@ -0,0 +1,84 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/cli/cli/command/container"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/spf13/cobra"
+
+	"github.com/docker/compose/v2/pkg/api"
+)
+
+type statsOptions struct {
+	ProjectOptions *ProjectOptions
+	all            bool
+	format         string
+	noStream       bool
+	noTrunc        bool
+}
+
+func statsCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
+	opts := statsOptions{
+		ProjectOptions: p,
+	}
+	cmd := &cobra.Command{
+		Use:   "stats [OPTIONS] [SERVICE]",
+		Short: "Display a live stream of container(s) resource usage statistics",
+		Args:  cobra.MaximumNArgs(1),
+		RunE: Adapt(func(ctx context.Context, args []string) error {
+			return runStats(ctx, dockerCli, opts, args)
+		}),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
+	}
+	flags := cmd.Flags()
+	flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
+	flags.StringVar(&opts.format, "format", "", `Format output using a custom template:
+'table':            Print output in table format with column headers (default)
+'table TEMPLATE':   Print output in table format using the given Go template
+'json':             Print in JSON format
+'TEMPLATE':         Print output using the given Go template.
+Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates`)
+	flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
+	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")
+	return cmd
+}
+
+func runStats(ctx context.Context, dockerCli command.Cli, opts statsOptions, service []string) error {
+	name, err := opts.ProjectOptions.toProjectName(dockerCli)
+	if err != nil {
+		return err
+	}
+	filter := []filters.KeyValuePair{
+		filters.Arg("label", fmt.Sprintf("%s=%s", api.ProjectLabel, name)),
+	}
+	if len(service) > 0 {
+		filter = append(filter, filters.Arg("label", fmt.Sprintf("%s=%s", api.ServiceLabel, service[0])))
+	}
+	args := filters.NewArgs(filter...)
+	return container.RunStats(ctx, dockerCli, &container.StatsOptions{
+		All:      opts.all,
+		NoStream: opts.noStream,
+		NoTrunc:  opts.noTrunc,
+		Format:   opts.format,
+		Filters:  &args,
+	})
+}

cmd/compose/stop.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -31,7 +32,7 @@ type stopOptions struct {
 	timeout     int
 }
 
-func stopCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func stopCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := stopOptions{
 		ProjectOptions: p,
 	}
@@ -42,9 +43,9 @@ func stopCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			opts.timeChanged = cmd.Flags().Changed("timeout")
 		},
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runStop(ctx, backend, opts, args)
+			return runStop(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
 	flags.IntVarP(&opts.timeout, "timeout", "t", 0, "Specify a shutdown timeout in seconds")
@@ -52,8 +53,8 @@ func stopCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
-func runStop(ctx context.Context, backend api.Service, opts stopOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+func runStop(ctx context.Context, dockerCli command.Cli, backend api.Service, opts stopOptions, services []string) error {
+	project, name, err := opts.projectOrName(dockerCli, services...)
 	if err != nil {
 		return err
 	}

cmd/compose/top.go

@@ -24,6 +24,7 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -33,7 +34,7 @@ type topOptions struct {
 	*ProjectOptions
 }
 
-func topCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func topCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := topOptions{
 		ProjectOptions: p,
 	}
@@ -41,15 +42,15 @@ func topCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *co
 		Use:   "top [SERVICES...]",
 		Short: "Display the running processes",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runTop(ctx, streams, backend, opts, args)
+			return runTop(ctx, dockerCli, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	return topCmd
 }
 
-func runTop(ctx context.Context, streams api.Streams, backend api.Service, opts topOptions, services []string) error {
-	projectName, err := opts.toProjectName()
+func runTop(ctx context.Context, dockerCli command.Cli, backend api.Service, opts topOptions, services []string) error {
+	projectName, err := opts.toProjectName(dockerCli)
 	if err != nil {
 		return err
 	}
@@ -63,8 +64,8 @@ func runTop(ctx context.Context, streams api.Streams, backend api.Service, opts
 	})
 
 	for _, container := range containers {
-		fmt.Fprintf(streams.Out(), "%s\n", container.Name)
-		err := psPrinter(streams.Out(), func(w io.Writer) {
+		fmt.Fprintf(dockerCli.Out(), "%s\n", container.Name)
+		err := psPrinter(dockerCli.Out(), func(w io.Writer) {
 			for _, proc := range container.Processes {
 				info := []interface{}{}
 				for _, p := range proc {

cmd/compose/up.go

@@ -18,10 +18,15 @@ package compose
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"strings"
 	"time"
 
-	"github.com/compose-spec/compose-go/types"
+	xprogress "github.com/moby/buildkit/util/progress/progressui"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/spf13/cobra"
 
@@ -51,27 +56,29 @@ type upOptions struct {
 	waitTimeout        int
 }
 
-func (opts upOptions) apply(project *types.Project, services []string) error {
+func (opts upOptions) apply(project *types.Project, services []string) (*types.Project, error) {
 	if opts.noDeps {
-		err := project.ForServices(services, types.IgnoreDependencies)
+		var err error
+		project, err = project.WithSelectedServices(services, types.IgnoreDependencies)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	if opts.exitCodeFrom != "" {
 		_, err := project.GetService(opts.exitCodeFrom)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
-	return nil
+	return project, nil
 }
 
-func upCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cobra.Command {
+func upCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	up := upOptions{}
 	create := createOptions{}
+	build := buildOptions{ProjectOptions: p}
 	upCmd := &cobra.Command{
 		Use:   "up [OPTIONS] [SERVICE...]",
 		Short: "Create and start containers",
@@ -80,20 +87,23 @@ func upCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cob
 			create.timeChanged = cmd.Flags().Changed("timeout")
 			return validateFlags(&up, &create)
 		}),
-		RunE: p.WithServices(func(ctx context.Context, project *types.Project, services []string) error {
+		RunE: p.WithServices(dockerCli, func(ctx context.Context, project *types.Project, services []string) error {
 			create.ignoreOrphans = utils.StringToBool(project.Environment[ComposeIgnoreOrphans])
 			if create.ignoreOrphans && create.removeOrphans {
-				return fmt.Errorf("%s and --remove-orphans cannot be combined", ComposeIgnoreOrphans)
+				return fmt.Errorf("cannot combine %s and --remove-orphans", ComposeIgnoreOrphans)
 			}
-			return runUp(ctx, streams, backend, create, up, project, services)
+			if len(up.attach) != 0 && up.attachDependencies {
+				return errors.New("cannot combine --attach and --attach-dependencies")
+			}
+			return runUp(ctx, dockerCli, backend, create, up, build, project, services)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := upCmd.Flags()
 	flags.BoolVarP(&up.Detach, "detach", "d", false, "Detached mode: Run containers in the background")
 	flags.BoolVar(&create.Build, "build", false, "Build images before starting containers.")
-	flags.BoolVar(&create.noBuild, "no-build", false, "Don't build an image, even if it's missing.")
-	flags.StringVar(&create.Pull, "pull", "missing", `Pull image before running ("always"|"missing"|"never")`)
+	flags.BoolVar(&create.noBuild, "no-build", false, "Don't build an image, even if it's policy.")
+	flags.StringVar(&create.Pull, "pull", "policy", `Pull image before running ("always"|"missing"|"never")`)
 	flags.BoolVar(&create.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file.")
 	flags.StringArrayVar(&create.scale, "scale", []string{}, "Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present.")
 	flags.BoolVar(&up.noColor, "no-color", false, "Produce monochrome output.")
@@ -108,12 +118,12 @@ func upCommand(p *ProjectOptions, streams api.Streams, backend api.Service) *cob
 	flags.BoolVar(&up.noDeps, "no-deps", false, "Don't start linked services.")
 	flags.BoolVar(&create.recreateDeps, "always-recreate-deps", false, "Recreate dependent containers. Incompatible with --no-recreate.")
 	flags.BoolVarP(&create.noInherit, "renew-anon-volumes", "V", false, "Recreate anonymous volumes instead of retrieving data from the previous containers.")
-	flags.BoolVar(&up.attachDependencies, "attach-dependencies", false, "Attach to dependent containers.")
 	flags.BoolVar(&create.quietPull, "quiet-pull", false, "Pull without printing progress information.")
-	flags.StringArrayVar(&up.attach, "attach", []string{}, "Attach to service output.")
-	flags.StringArrayVar(&up.noAttach, "no-attach", []string{}, "Don't attach to specified service.")
+	flags.StringArrayVar(&up.attach, "attach", []string{}, "Restrict attaching to the specified services. Incompatible with --attach-dependencies.")
+	flags.StringArrayVar(&up.noAttach, "no-attach", []string{}, "Do not attach (stream logs) to the specified services.")
+	flags.BoolVar(&up.attachDependencies, "attach-dependencies", false, "Automatically attach to log output of dependent services.")
 	flags.BoolVar(&up.wait, "wait", false, "Wait for services to be running|healthy. Implies detached mode.")
-	flags.IntVar(&up.waitTimeout, "wait-timeout", 0, "timeout waiting for application to be running|healthy.")
+	flags.IntVar(&up.waitTimeout, "wait-timeout", 0, "Maximum duration to wait for the project to be running|healthy.")
 
 	return upCmd
 }
@@ -143,7 +153,16 @@ func validateFlags(up *upOptions, create *createOptions) error {
 	return nil
 }
 
-func runUp(ctx context.Context, streams api.Streams, backend api.Service, createOptions createOptions, upOptions upOptions, project *types.Project, services []string) error {
+func runUp(
+	ctx context.Context,
+	dockerCli command.Cli,
+	backend api.Service,
+	createOptions createOptions,
+	upOptions upOptions,
+	buildOptions buildOptions,
+	project *types.Project,
+	services []string,
+) error {
 	if len(project.Services) == 0 {
 		return fmt.Errorf("no service selected")
 	}
@@ -153,43 +172,29 @@ func runUp(ctx context.Context, streams api.Streams, backend api.Service, create
 		return err
 	}
 
-	err = upOptions.apply(project, services)
+	project, err = upOptions.apply(project, services)
 	if err != nil {
 		return err
 	}
 
-	var consumer api.LogConsumer
-	if !upOptions.Detach {
-		consumer = formatter.NewLogConsumer(ctx, streams.Out(), streams.Err(), !upOptions.noColor, !upOptions.noPrefix, upOptions.timestamp)
-	}
-
-	attachTo := utils.Set[string]{}
-	if len(upOptions.attach) > 0 {
-		attachTo.AddAll(upOptions.attach...)
-	}
-	if upOptions.attachDependencies {
-		if err := project.WithServices(attachTo.Elements(), func(s types.ServiceConfig) error {
-			if s.Attach == nil || *s.Attach {
-				attachTo.Add(s.Name)
-			}
-			return nil
-		}); err != nil {
+	var build *api.BuildOptions
+	if !createOptions.noBuild {
+		if createOptions.quietPull {
+			buildOptions.Progress = string(xprogress.QuietMode)
+		}
+		// BuildOptions here is nested inside CreateOptions, so
+		// no service list is passed, it will implicitly pick all
+		// services being created, which includes any explicitly
+		// specified via "services" arg here as well as deps
+		bo, err := buildOptions.toAPIBuildOptions(nil)
+		if err != nil {
 			return err
 		}
+		build = &bo
 	}
-	if len(attachTo) == 0 {
-		if err := project.WithServices(services, func(s types.ServiceConfig) error {
-			if s.Attach == nil || *s.Attach {
-				attachTo.Add(s.Name)
-			}
-			return nil
-		}); err != nil {
-			return err
-		}
-	}
-	attachTo.RemoveAll(upOptions.noAttach...)
 
 	create := api.CreateOptions{
+		Build:                build,
 		Services:             services,
 		RemoveOrphans:        createOptions.removeOrphans,
 		IgnoreOrphans:        createOptions.ignoreOrphans,
@@ -204,14 +209,48 @@ func runUp(ctx context.Context, streams api.Streams, backend api.Service, create
 		return backend.Create(ctx, project, create)
 	}
 
-	timeout := time.Duration(upOptions.waitTimeout) * time.Second
+	var consumer api.LogConsumer
+	var attach []string
+	if !upOptions.Detach {
+		consumer = formatter.NewLogConsumer(ctx, dockerCli.Out(), dockerCli.Err(), !upOptions.noColor, !upOptions.noPrefix, upOptions.timestamp)
 
+		var attachSet utils.Set[string]
+		if len(upOptions.attach) != 0 {
+			// services are passed explicitly with --attach, verify they're valid and then use them as-is
+			attachSet = utils.NewSet(upOptions.attach...)
+			unexpectedSvcs := attachSet.Diff(utils.NewSet(project.ServiceNames()...))
+			if len(unexpectedSvcs) != 0 {
+				return fmt.Errorf("cannot attach to services not included in up: %s", strings.Join(unexpectedSvcs.Elements(), ", "))
+			}
+		} else {
+			// mark services being launched (and potentially their deps) for attach
+			// if they didn't opt-out via Compose YAML
+			attachSet = utils.NewSet[string]()
+			var dependencyOpt types.DependencyOption = types.IgnoreDependencies
+			if upOptions.attachDependencies {
+				dependencyOpt = types.IncludeDependencies
+			}
+			if err := project.ForEachService(services, func(serviceName string, s *types.ServiceConfig) error {
+				if s.Attach == nil || *s.Attach {
+					attachSet.Add(serviceName)
+				}
+				return nil
+			}, dependencyOpt); err != nil {
+				return err
+			}
+		}
+		// filter out any services that have been explicitly marked for ignore with `--no-attach`
+		attachSet.RemoveAll(upOptions.noAttach...)
+		attach = attachSet.Elements()
+	}
+
+	timeout := time.Duration(upOptions.waitTimeout) * time.Second
 	return backend.Up(ctx, project, api.UpOptions{
 		Create: create,
 		Start: api.StartOptions{
 			Project:      project,
 			Attach:       consumer,
-			AttachTo:     attachTo.Elements(),
+			AttachTo:     attach,
 			ExitCodeFrom: upOptions.exitCodeFrom,
 			CascadeStop:  upOptions.cascadeStop,
 			Wait:         upOptions.wait,
@@ -221,22 +260,12 @@ func runUp(ctx context.Context, streams api.Streams, backend api.Service, create
 	})
 }
 
-func setServiceScale(project *types.Project, name string, replicas uint64) error {
-	for i, s := range project.Services {
-		if s.Name != name {
-			continue
-		}
-
-		service, err := project.GetService(name)
-		if err != nil {
-			return err
-		}
-		if service.Deploy == nil {
-			service.Deploy = &types.DeployConfig{}
-		}
-		service.Deploy.Replicas = &replicas
-		project.Services[i] = service
-		return nil
+func setServiceScale(project *types.Project, name string, replicas int) error {
+	service, err := project.GetService(name)
+	if err != nil {
+		return err
 	}
-	return fmt.Errorf("unknown service %q", name)
+	service.SetScale(replicas)
+	project.Services[name] = service
+	return nil
 }

cmd/compose/up_test.go

@@ -19,25 +19,33 @@ package compose
 import (
 	"testing"
 
-	"github.com/compose-spec/compose-go/types"
+	"github.com/compose-spec/compose-go/v2/types"
 	"gotest.tools/v3/assert"
 )
 
 func TestApplyScaleOpt(t *testing.T) {
 	p := types.Project{
-		Services: []types.ServiceConfig{
-			{
+		Services: types.Services{
+			"foo": {
 				Name: "foo",
 			},
-			{
+			"bar": {
 				Name: "bar",
+				Deploy: &types.DeployConfig{
+					Mode: "test",
+				},
 			},
 		},
 	}
-	opt := createOptions{scale: []string{"foo=2"}}
-	err := opt.Apply(&p)
+	err := applyScaleOpts(&p, []string{"foo=2", "bar=3"})
 	assert.NilError(t, err)
 	foo, err := p.GetService("foo")
 	assert.NilError(t, err)
-	assert.Equal(t, *foo.Deploy.Replicas, uint64(2))
+	assert.Equal(t, *foo.Scale, 2)
+
+	bar, err := p.GetService("bar")
+	assert.NilError(t, err)
+	assert.Equal(t, *bar.Scale, 3)
+	assert.Equal(t, *bar.Deploy.Replicas, 3)
+
 }

cmd/compose/version.go

@@ -33,14 +33,14 @@ type versionOptions struct {
 	short  bool
 }
 
-func versionCommand(streams command.Cli) *cobra.Command {
+func versionCommand(dockerCli command.Cli) *cobra.Command {
 	opts := versionOptions{}
 	cmd := &cobra.Command{
 		Use:   "version [OPTIONS]",
 		Short: "Show the Docker Compose version information",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
-			runVersion(opts, streams)
+			runVersion(opts, dockerCli)
 			return nil
 		},
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
@@ -57,14 +57,14 @@ func versionCommand(streams command.Cli) *cobra.Command {
 	return cmd
 }
 
-func runVersion(opts versionOptions, streams command.Cli) {
+func runVersion(opts versionOptions, dockerCli command.Cli) {
 	if opts.short {
-		fmt.Fprintln(streams.Out(), strings.TrimPrefix(internal.Version, "v"))
+		fmt.Fprintln(dockerCli.Out(), strings.TrimPrefix(internal.Version, "v"))
 		return
 	}
 	if opts.format == formatter.JSON {
-		fmt.Fprintf(streams.Out(), "{\"version\":%q}\n", internal.Version)
+		fmt.Fprintf(dockerCli.Out(), "{\"version\":%q}\n", internal.Version)
 		return
 	}
-	fmt.Fprintln(streams.Out(), "Docker Compose version", internal.Version)
+	fmt.Fprintln(dockerCli.Out(), "Docker Compose version", internal.Version)
 }

cmd/compose/viz.go

@@ -22,6 +22,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -34,7 +35,7 @@ type vizOptions struct {
 	indentationStr   string
 }
 
-func vizCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func vizCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := vizOptions{
 		ProjectOptions: p,
 	}
@@ -50,7 +51,7 @@ func vizCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 			return err
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runViz(ctx, backend, &opts)
+			return runViz(ctx, dockerCli, backend, &opts)
 		}),
 	}
 
@@ -62,9 +63,9 @@ func vizCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
-func runViz(ctx context.Context, backend api.Service, opts *vizOptions) error {
+func runViz(ctx context.Context, dockerCli command.Cli, backend api.Service, opts *vizOptions) error {
 	_, _ = fmt.Fprintln(os.Stderr, "viz command is EXPERIMENTAL")
-	project, err := opts.ToProject(nil)
+	project, err := opts.ToProject(dockerCli, nil)
 	if err != nil {
 		return err
 	}

cmd/compose/wait.go

@@ -21,6 +21,7 @@ import (
 	"os"
 
 	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -33,7 +34,7 @@ type waitOptions struct {
 	downProject bool
 }
 
-func waitCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
+func waitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := waitOptions{
 		ProjectOptions: p,
 	}
@@ -46,7 +47,7 @@ func waitCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 		Args:  cli.RequiresMinArgs(1),
 		RunE: Adapt(func(ctx context.Context, services []string) error {
 			opts.services = services
-			statusCode, err = runWait(ctx, backend, &opts)
+			statusCode, err = runWait(ctx, dockerCli, backend, &opts)
 			return err
 		}),
 		PostRun: func(cmd *cobra.Command, args []string) {
@@ -59,8 +60,8 @@ func waitCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
-func runWait(ctx context.Context, backend api.Service, opts *waitOptions) (int64, error) {
-	_, name, err := opts.projectOrName()
+func runWait(ctx context.Context, dockerCli command.Cli, backend api.Service, opts *waitOptions) (int64, error) {
+	_, name, err := opts.projectOrName(dockerCli)
 	if err != nil {
 		return 0, err
 	}

cmd/compose/watch.go

@@ -19,43 +19,102 @@ package compose
 import (
 	"context"
 	"fmt"
-	"os"
 
+	"github.com/compose-spec/compose-go/v2/types"
+
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose/v2/internal/locker"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
 
 type watchOptions struct {
 	*ProjectOptions
 	quiet bool
+	noUp  bool
 }
 
-func watchCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
-	opts := watchOptions{
+func watchCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+	watchOpts := watchOptions{
+		ProjectOptions: p,
+	}
+	buildOpts := buildOptions{
 		ProjectOptions: p,
 	}
 	cmd := &cobra.Command{
 		Use:   "watch [SERVICE...]",
-		Short: "EXPERIMENTAL - Watch build context for service and rebuild/refresh containers when files are updated",
+		Short: "Watch build context for service and rebuild/refresh containers when files are updated",
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			return nil
 		}),
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runWatch(ctx, backend, opts, args)
+		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
+			if cmd.Parent().Name() == "alpha" {
+				logrus.Warn("watch command is now available as a top level command")
+			}
+			return runWatch(ctx, dockerCli, backend, watchOpts, buildOpts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 
-	cmd.Flags().BoolVar(&opts.quiet, "quiet", false, "hide build output")
+	cmd.Flags().BoolVar(&watchOpts.quiet, "quiet", false, "hide build output")
+	cmd.Flags().BoolVar(&watchOpts.noUp, "no-up", false, "Do not build & start services before watching")
 	return cmd
 }
 
-func runWatch(ctx context.Context, backend api.Service, opts watchOptions, services []string) error {
-	fmt.Fprintln(os.Stderr, "watch command is EXPERIMENTAL")
-	project, err := opts.ToProject(nil)
+func runWatch(ctx context.Context, dockerCli command.Cli, backend api.Service, watchOpts watchOptions, buildOpts buildOptions, services []string) error {
+	project, err := watchOpts.ToProject(dockerCli, nil)
 	if err != nil {
 		return err
 	}
 
-	return backend.Watch(ctx, project, services, api.WatchOptions{})
+	if err := applyPlatforms(project, true); err != nil {
+		return err
+	}
+
+	build, err := buildOpts.toAPIBuildOptions(nil)
+	if err != nil {
+		return err
+	}
+
+	// validation done -- ensure we have the lockfile for this project before doing work
+	l, err := locker.NewPidfile(project.Name)
+	if err != nil {
+		return fmt.Errorf("cannot take exclusive lock for project %q: %w", project.Name, err)
+	}
+	if err := l.Lock(); err != nil {
+		return fmt.Errorf("cannot take exclusive lock for project %q: %w", project.Name, err)
+	}
+
+	if !watchOpts.noUp {
+		for index, service := range project.Services {
+			if service.Build != nil && service.Develop != nil {
+				service.PullPolicy = types.PullPolicyBuild
+			}
+			project.Services[index] = service
+		}
+		upOpts := api.UpOptions{
+			Create: api.CreateOptions{
+				Build:                &build,
+				Services:             services,
+				RemoveOrphans:        false,
+				Recreate:             api.RecreateDiverged,
+				RecreateDependencies: api.RecreateNever,
+				Inherit:              true,
+				QuietPull:            watchOpts.quiet,
+			},
+			Start: api.StartOptions{
+				Project:     project,
+				Attach:      nil,
+				CascadeStop: false,
+				Services:    services,
+			},
+		}
+		if err := backend.Up(ctx, project, upOpts); err != nil {
+			return err
+		}
+	}
+	return backend.Watch(ctx, project, services, api.WatchOptions{
+		Build: build,
+	})
 }

cmd/formatter/container.go

@@ -0,0 +1,287 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package formatter
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/docker/cli/cli/command/formatter"
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/pkg/stringid"
+	"github.com/docker/go-units"
+)
+
+const (
+	defaultContainerTableFormat = "table {{.Name}}\t{{.Image}}\t{{.Command}}\t{{.Service}}\t{{.RunningFor}}\t{{.Status}}\t{{.Ports}}"
+
+	nameHeader       = "NAME"
+	projectHeader    = "PROJECT"
+	serviceHeader    = "SERVICE"
+	commandHeader    = "COMMAND"
+	runningForHeader = "CREATED"
+	mountsHeader     = "MOUNTS"
+	localVolumes     = "LOCAL VOLUMES"
+	networksHeader   = "NETWORKS"
+)
+
+// NewContainerFormat returns a Format for rendering using a Context
+func NewContainerFormat(source string, quiet bool, size bool) formatter.Format {
+	switch source {
+	case formatter.TableFormatKey, "": // table formatting is the default if none is set.
+		if quiet {
+			return formatter.DefaultQuietFormat
+		}
+		format := defaultContainerTableFormat
+		if size {
+			format += `\t{{.Size}}`
+		}
+		return formatter.Format(format)
+	case formatter.RawFormatKey:
+		if quiet {
+			return `container_id: {{.ID}}`
+		}
+		format := `container_id: {{.ID}}
+image: {{.Image}}
+command: {{.Command}}
+created_at: {{.CreatedAt}}
+state: {{- pad .State 1 0}}
+status: {{- pad .Status 1 0}}
+names: {{.Names}}
+labels: {{- pad .Labels 1 0}}
+ports: {{- pad .Ports 1 0}}
+`
+		if size {
+			format += `size: {{.Size}}\n`
+		}
+		return formatter.Format(format)
+	default: // custom format
+		if quiet {
+			return formatter.DefaultQuietFormat
+		}
+		return formatter.Format(source)
+	}
+}
+
+// ContainerWrite renders the context for a list of containers
+func ContainerWrite(ctx formatter.Context, containers []api.ContainerSummary) error {
+	render := func(format func(subContext formatter.SubContext) error) error {
+		for _, container := range containers {
+			err := format(&ContainerContext{trunc: ctx.Trunc, c: container})
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return ctx.Write(NewContainerContext(), render)
+}
+
+// ContainerContext is a struct used for rendering a list of containers in a Go template.
+type ContainerContext struct {
+	formatter.HeaderContext
+	trunc bool
+	c     api.ContainerSummary
+
+	// FieldsUsed is used in the pre-processing step to detect which fields are
+	// used in the template. It's currently only used to detect use of the .Size
+	// field which (if used) automatically sets the '--size' option when making
+	// the API call.
+	FieldsUsed map[string]interface{}
+}
+
+// NewContainerContext creates a new context for rendering containers
+func NewContainerContext() *ContainerContext {
+	containerCtx := ContainerContext{}
+	containerCtx.Header = formatter.SubHeaderContext{
+		"ID":         formatter.ContainerIDHeader,
+		"Name":       nameHeader,
+		"Project":    projectHeader,
+		"Service":    serviceHeader,
+		"Image":      formatter.ImageHeader,
+		"Command":    commandHeader,
+		"CreatedAt":  formatter.CreatedAtHeader,
+		"RunningFor": runningForHeader,
+		"Ports":      formatter.PortsHeader,
+		"State":      formatter.StateHeader,
+		"Status":     formatter.StatusHeader,
+		"Size":       formatter.SizeHeader,
+		"Labels":     formatter.LabelsHeader,
+	}
+	return &containerCtx
+}
+
+// MarshalJSON makes ContainerContext implement json.Marshaler
+func (c *ContainerContext) MarshalJSON() ([]byte, error) {
+	return formatter.MarshalJSON(c)
+}
+
+// ID returns the container's ID as a string. Depending on the `--no-trunc`
+// option being set, the full or truncated ID is returned.
+func (c *ContainerContext) ID() string {
+	if c.trunc {
+		return stringid.TruncateID(c.c.ID)
+	}
+	return c.c.ID
+}
+
+func (c *ContainerContext) Name() string {
+	return c.c.Name
+}
+
+// Names returns a comma-separated string of the container's names, with their
+// slash (/) prefix stripped. Additional names for the container (related to the
+// legacy `--link` feature) are omitted.
+func (c *ContainerContext) Names() string {
+	names := formatter.StripNamePrefix(c.c.Names)
+	if c.trunc {
+		for _, name := range names {
+			if len(strings.Split(name, "/")) == 1 {
+				names = []string{name}
+				break
+			}
+		}
+	}
+	return strings.Join(names, ",")
+}
+
+func (c *ContainerContext) Service() string {
+	return c.c.Service
+}
+
+func (c *ContainerContext) Project() string {
+	return c.c.Project
+}
+
+func (c *ContainerContext) Image() string {
+	return c.c.Image
+}
+
+func (c *ContainerContext) Command() string {
+	command := c.c.Command
+	if c.trunc {
+		command = formatter.Ellipsis(command, 20)
+	}
+	return strconv.Quote(command)
+}
+
+func (c *ContainerContext) CreatedAt() string {
+	return time.Unix(c.c.Created, 0).String()
+}
+
+func (c *ContainerContext) RunningFor() string {
+	createdAt := time.Unix(c.c.Created, 0)
+	return units.HumanDuration(time.Now().UTC().Sub(createdAt)) + " ago"
+}
+
+func (c *ContainerContext) ExitCode() int {
+	return c.c.ExitCode
+}
+
+func (c *ContainerContext) State() string {
+	return c.c.State
+}
+
+func (c *ContainerContext) Status() string {
+	return c.c.Status
+}
+
+func (c *ContainerContext) Health() string {
+	return c.c.Health
+}
+
+func (c *ContainerContext) Publishers() api.PortPublishers {
+	return c.c.Publishers
+}
+
+func (c *ContainerContext) Ports() string {
+	var ports []types.Port
+	for _, publisher := range c.c.Publishers {
+		ports = append(ports, types.Port{
+			IP:          publisher.URL,
+			PrivatePort: uint16(publisher.TargetPort),
+			PublicPort:  uint16(publisher.PublishedPort),
+			Type:        publisher.Protocol,
+		})
+	}
+	return formatter.DisplayablePorts(ports)
+}
+
+// Labels returns a comma-separated string of labels present on the container.
+func (c *ContainerContext) Labels() string {
+	if c.c.Labels == nil {
+		return ""
+	}
+
+	var joinLabels []string
+	for k, v := range c.c.Labels {
+		joinLabels = append(joinLabels, fmt.Sprintf("%s=%s", k, v))
+	}
+	return strings.Join(joinLabels, ",")
+}
+
+// Label returns the value of the label with the given name or an empty string
+// if the given label does not exist.
+func (c *ContainerContext) Label(name string) string {
+	if c.c.Labels == nil {
+		return ""
+	}
+	return c.c.Labels[name]
+}
+
+// Mounts returns a comma-separated string of mount names present on the container.
+// If the trunc option is set, names can be truncated (ellipsized).
+func (c *ContainerContext) Mounts() string {
+	var mounts []string
+	for _, name := range c.c.Mounts {
+		if c.trunc {
+			name = formatter.Ellipsis(name, 15)
+		}
+		mounts = append(mounts, name)
+	}
+	return strings.Join(mounts, ",")
+}
+
+// LocalVolumes returns the number of volumes using the "local" volume driver.
+func (c *ContainerContext) LocalVolumes() string {
+	return fmt.Sprintf("%d", c.c.LocalVolumes)
+}
+
+// Networks returns a comma-separated string of networks that the container is
+// attached to.
+func (c *ContainerContext) Networks() string {
+	return strings.Join(c.c.Networks, ",")
+}
+
+// Size returns the container's size and virtual size (e.g. "2B (virtual 21.5MB)")
+func (c *ContainerContext) Size() string {
+	if c.FieldsUsed == nil {
+		c.FieldsUsed = map[string]interface{}{}
+	}
+	c.FieldsUsed["Size"] = struct{}{}
+	srw := units.HumanSizeWithPrecision(float64(c.c.SizeRw), 3)
+	sv := units.HumanSizeWithPrecision(float64(c.c.SizeRootFs), 3)
+
+	sf := srw
+	if c.c.SizeRootFs > 0 {
+		sf = fmt.Sprintf("%s (virtual %s)", srw, sv)
+	}
+	return sf
+}

cmd/formatter/formatter.go

@@ -23,8 +23,6 @@ import (
 	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
-
-	"github.com/pkg/errors"
 )
 
 // Print prints formatted lists in different formats
@@ -67,7 +65,7 @@ func Print(toJSON interface{}, format string, outWriter io.Writer, writerFn func
 			_, _ = fmt.Fprintln(outWriter, outJSON)
 		}
 	default:
-		return errors.Wrapf(api.ErrParsingFailed, "format value %q could not be parsed", format)
+		return fmt.Errorf("format value %q could not be parsed: %w", format, api.ErrParsingFailed)
 	}
 	return nil
 }

cmd/main.go

@@ -24,28 +24,31 @@ import (
 	"github.com/docker/cli/cli-plugins/plugin"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/cmd/cmdtrace"
+	"github.com/docker/docker/client"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/cmd/compatibility"
 	commands "github.com/docker/compose/v2/cmd/compose"
 	"github.com/docker/compose/v2/internal"
-	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
 )
 
 func pluginMain() {
 	plugin.Run(func(dockerCli command.Cli) *cobra.Command {
-		serviceProxy := api.NewServiceProxy().WithService(compose.NewComposeService(dockerCli))
-		cmd := commands.RootCommand(dockerCli, serviceProxy)
+		backend := compose.NewComposeService(dockerCli)
+		cmd := commands.RootCommand(dockerCli, backend)
 		originalPreRun := cmd.PersistentPreRunE
 		cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 			// initialize the dockerCli instance
 			if err := plugin.PersistentPreRunE(cmd, args); err != nil {
 				return err
 			}
+			// compose-specific initialization
+			dockerCliPostInitialize(dockerCli)
+
 			// TODO(milas): add an env var to enable logging from the
 			// OTel components for debugging purposes
-			_ = cmdtrace.Setup(cmd, dockerCli)
+			_ = cmdtrace.Setup(cmd, dockerCli, os.Args[1:])
 
 			if originalPreRun != nil {
 				return originalPreRun(cmd, args)
@@ -68,6 +71,22 @@ func pluginMain() {
 		})
 }
 
+// dockerCliPostInitialize performs Compose-specific configuration for the
+// command.Cli instance provided by the plugin.Run() initialization.
+//
+// NOTE: This must be called AFTER plugin.PersistentPreRunE.
+func dockerCliPostInitialize(dockerCli command.Cli) {
+	// HACK(milas): remove once docker/cli#4574 is merged; for now,
+	// set it in a rather roundabout way by grabbing the underlying
+	// concrete client and manually invoking an option on it
+	_ = dockerCli.Apply(func(cli *command.DockerCli) error {
+		if mobyClient, ok := cli.Client().(*client.Client); ok {
+			_ = client.WithUserAgent("compose/" + internal.Version)(mobyClient)
+		}
+		return nil
+	})
+}
+
 func main() {
 	if plugin.RunningStandalone() {
 		os.Args = append([]string{"docker"}, compatibility.Convert(os.Args[1:])...)

docs/reference/compose.md

@@ -5,34 +5,38 @@ Define and run multi-container applications with Docker.
 
 ### Subcommands
 
-| Name                            | Description                                                             |
-|:--------------------------------|:------------------------------------------------------------------------|
-| [`build`](compose_build.md)     | Build or rebuild services                                               |
-| [`config`](compose_config.md)   | Parse, resolve and render compose file in canonical format              |
-| [`cp`](compose_cp.md)           | Copy files/folders between a service container and the local filesystem |
-| [`create`](compose_create.md)   | Creates containers for a service.                                       |
-| [`down`](compose_down.md)       | Stop and remove containers, networks                                    |
-| [`events`](compose_events.md)   | Receive real time events from containers.                               |
-| [`exec`](compose_exec.md)       | Execute a command in a running container.                               |
-| [`images`](compose_images.md)   | List images used by the created containers                              |
-| [`kill`](compose_kill.md)       | Force stop service containers.                                          |
-| [`logs`](compose_logs.md)       | View output from containers                                             |
-| [`ls`](compose_ls.md)           | List running compose projects                                           |
-| [`pause`](compose_pause.md)     | Pause services                                                          |
-| [`port`](compose_port.md)       | Print the public port for a port binding.                               |
-| [`ps`](compose_ps.md)           | List containers                                                         |
-| [`pull`](compose_pull.md)       | Pull service images                                                     |
-| [`push`](compose_push.md)       | Push service images                                                     |
-| [`restart`](compose_restart.md) | Restart service containers                                              |
-| [`rm`](compose_rm.md)           | Removes stopped service containers                                      |
-| [`run`](compose_run.md)         | Run a one-off command on a service.                                     |
-| [`start`](compose_start.md)     | Start services                                                          |
-| [`stop`](compose_stop.md)       | Stop services                                                           |
-| [`top`](compose_top.md)         | Display the running processes                                           |
-| [`unpause`](compose_unpause.md) | Unpause services                                                        |
-| [`up`](compose_up.md)           | Create and start containers                                             |
-| [`version`](compose_version.md) | Show the Docker Compose version information                             |
-| [`wait`](compose_wait.md)       | Block until the first service container stops                           |
+| Name                            | Description                                                                              |
+|:--------------------------------|:-----------------------------------------------------------------------------------------|
+| [`attach`](compose_attach.md)   | Attach local standard input, output, and error streams to a service's running container. |
+| [`build`](compose_build.md)     | Build or rebuild services                                                                |
+| [`config`](compose_config.md)   | Parse, resolve and render compose file in canonical format                               |
+| [`cp`](compose_cp.md)           | Copy files/folders between a service container and the local filesystem                  |
+| [`create`](compose_create.md)   | Creates containers for a service.                                                        |
+| [`down`](compose_down.md)       | Stop and remove containers, networks                                                     |
+| [`events`](compose_events.md)   | Receive real time events from containers.                                                |
+| [`exec`](compose_exec.md)       | Execute a command in a running container.                                                |
+| [`images`](compose_images.md)   | List images used by the created containers                                               |
+| [`kill`](compose_kill.md)       | Force stop service containers.                                                           |
+| [`logs`](compose_logs.md)       | View output from containers                                                              |
+| [`ls`](compose_ls.md)           | List running compose projects                                                            |
+| [`pause`](compose_pause.md)     | Pause services                                                                           |
+| [`port`](compose_port.md)       | Print the public port for a port binding.                                                |
+| [`ps`](compose_ps.md)           | List containers                                                                          |
+| [`pull`](compose_pull.md)       | Pull service images                                                                      |
+| [`push`](compose_push.md)       | Push service images                                                                      |
+| [`restart`](compose_restart.md) | Restart service containers                                                               |
+| [`rm`](compose_rm.md)           | Removes stopped service containers                                                       |
+| [`run`](compose_run.md)         | Run a one-off command on a service.                                                      |
+| [`scale`](compose_scale.md)     | Scale services                                                                           |
+| [`start`](compose_start.md)     | Start services                                                                           |
+| [`stats`](compose_stats.md)     | Display a live stream of container(s) resource usage statistics                          |
+| [`stop`](compose_stop.md)       | Stop services                                                                            |
+| [`top`](compose_top.md)         | Display the running processes                                                            |
+| [`unpause`](compose_unpause.md) | Unpause services                                                                         |
+| [`up`](compose_up.md)           | Create and start containers                                                              |
+| [`version`](compose_version.md) | Show the Docker Compose version information                                              |
+| [`wait`](compose_wait.md)       | Block until the first service container stops                                            |
+| [`watch`](compose_watch.md)     | Watch build context for service and rebuild/refresh containers when files are updated    |
 
 
 ### Options
@@ -55,7 +59,7 @@ Define and run multi-container applications with Docker.
 
 ## Description
 
-You can use compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
+You can use the compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
 multiple services in Docker containers.
 
 ### Use `-f` to specify the name and path of one or more Compose files
@@ -144,16 +148,16 @@ demo_1  | 64 bytes from 127.0.0.1: seq=0 ttl=64 time=0.095 ms
 ### Use profiles to enable optional services
 
 Use `--profile` to specify one or more active profiles
-Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services
+Calling `docker compose --profile frontend up` starts the services with the profile `frontend` and services
 without any specified profiles.
-You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` will be enabled.
+You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` is enabled.
 
 Profiles can also be set by `COMPOSE_PROFILES` environment variable.
 
 ### Configuring parallelism
 
 Use `--parallel` to specify the maximum level of parallelism for concurrent engine calls.
-Calling `docker compose --parallel 1 pull` will pull the pullable images defined in the Compose file
+Calling `docker compose --parallel 1 pull` pulls the pullable images defined in the Compose file
 one at a time. This can also be used to control build concurrency.
 
 Parallelism can also be set by the `COMPOSE_PARALLEL_LIMIT` environment variable.
@@ -169,7 +173,7 @@ and `COMPOSE_PARALLEL_LIMIT` does the same as the `--parallel` flag.
 
 If flags are explicitly set on the command line, the associated environment variable is ignored.
 
-Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` will stop docker compose from detecting orphaned
+Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` stops docker compose from detecting orphaned
 containers for the project.
 
 ### Use Dry Run mode to test your command

docs/reference/compose_alpha_dry-run.md

@@ -1,7 +1,7 @@
 # docker compose alpha dry-run
 
 <!---MARKER_GEN_START-->
-EXPERIMENTAL - Dry run command allow you to test a command without applying changes
+Dry run command allows you to test a command without applying changes.
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_alpha_publish.md

@@ -0,0 +1,16 @@
+# docker compose alpha publish
+
+<!---MARKER_GEN_START-->
+Publish compose application
+
+### Options
+
+| Name                      | Type     | Default | Description                                                                    |
+|:--------------------------|:---------|:--------|:-------------------------------------------------------------------------------|
+| `--dry-run`               |          |         | Execute command in dry run mode                                                |
+| `--oci-version`           | `string` |         | OCI Image/Artifact specification version (automatically determined by default) |
+| `--resolve-image-digests` |          |         | Pin image tags to digests.                                                     |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/compose_alpha_scale.md

@@ -0,0 +1,15 @@
+# docker compose alpha scale
+
+<!---MARKER_GEN_START-->
+Scale services. 
+
+### Options
+
+| Name        | Type | Default | Description                     |
+|:------------|:-----|:--------|:--------------------------------|
+| `--dry-run` |      |         | Execute command in dry run mode |
+| `--no-deps` |      |         | Don't start linked services    |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/compose_alpha_watch.md

@@ -1,14 +1,15 @@
 # docker compose alpha watch
 
 <!---MARKER_GEN_START-->
-EXPERIMENTAL - Watch build context for service and rebuild/refresh containers when files are updated
+Watch build context for service and rebuild/refresh containers when files are updated
 
 ### Options
 
-| Name        | Type | Default | Description                     |
-|:------------|:-----|:--------|:--------------------------------|
-| `--dry-run` |      |         | Execute command in dry run mode |
-| `--quiet`   |      |         | hide build output               |
+| Name        | Type | Default | Description                                   |
+|:------------|:-----|:--------|:----------------------------------------------|
+| `--dry-run` |      |         | Execute command in dry run mode               |
+| `--no-up`   |      |         | Do not build & start services before watching |
+| `--quiet`   |      |         | hide build output                             |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_attach.md

@@ -0,0 +1,18 @@
+# docker compose attach
+
+<!---MARKER_GEN_START-->
+Attach local standard input, output, and error streams to a service's running container.
+
+### Options
+
+| Name            | Type     | Default | Description                                               |
+|:----------------|:---------|:--------|:----------------------------------------------------------|
+| `--detach-keys` | `string` |         | Override the key sequence for detaching from a container. |
+| `--dry-run`     |          |         | Execute command in dry run mode                           |
+| `--index`       | `int`    | `0`     | index of the container if service has multiple replicas.  |
+| `--no-stdin`    |          |         | Do not attach STDIN                                       |
+| `--sig-proxy`   |          |         | Proxy all received signals to the process                 |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/compose_build.md

@@ -5,17 +5,18 @@ Build or rebuild services
 
 ### Options
 
-| Name             | Type          | Default | Description                                                                                                 |
-|:-----------------|:--------------|:--------|:------------------------------------------------------------------------------------------------------------|
-| `--build-arg`    | `stringArray` |         | Set build-time variables for services.                                                                      |
-| `--builder`      | `string`      |         | Set builder to use.                                                                                         |
-| `--dry-run`      |               |         | Execute command in dry run mode                                                                             |
-| `-m`, `--memory` | `bytes`       | `0`     | Set memory limit for the build container. Not supported by BuildKit.                                        |
-| `--no-cache`     |               |         | Do not use cache when building the image                                                                    |
-| `--pull`         |               |         | Always attempt to pull a newer version of the image.                                                        |
-| `--push`         |               |         | Push service images.                                                                                        |
-| `-q`, `--quiet`  |               |         | Don't print anything to STDOUT                                                                              |
-| `--ssh`          | `string`      |         | Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent) |
+| Name                  | Type          | Default | Description                                                                                                 |
+|:----------------------|:--------------|:--------|:------------------------------------------------------------------------------------------------------------|
+| `--build-arg`         | `stringArray` |         | Set build-time variables for services.                                                                      |
+| `--builder`           | `string`      |         | Set builder to use.                                                                                         |
+| `--dry-run`           |               |         | Execute command in dry run mode                                                                             |
+| `-m`, `--memory`      | `bytes`       | `0`     | Set memory limit for the build container. Not supported by BuildKit.                                        |
+| `--no-cache`          |               |         | Do not use cache when building the image                                                                    |
+| `--pull`              |               |         | Always attempt to pull a newer version of the image.                                                        |
+| `--push`              |               |         | Push service images.                                                                                        |
+| `-q`, `--quiet`       |               |         | Don't print anything to STDOUT                                                                              |
+| `--ssh`               | `string`      |         | Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent) |
+| `--with-dependencies` |               |         | Also build dependencies (transitively).                                                                     |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_config.md

@@ -31,6 +31,6 @@ Parse, resolve and render compose file in canonical format
 
 ## Description
 
-`docker compose config` renders the actual data model to be applied on the Docker engine.
-it merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
+`docker compose config` renders the actual data model to be applied on the Docker Engine.
+It merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
 the canonical format.

docs/reference/compose_create.md

@@ -5,16 +5,16 @@ Creates containers for a service.
 
 ### Options
 
-| Name               | Type          | Default   | Description                                                                                   |
-|:-------------------|:--------------|:----------|:----------------------------------------------------------------------------------------------|
-| `--build`          |               |           | Build images before starting containers.                                                      |
-| `--dry-run`        |               |           | Execute command in dry run mode                                                               |
-| `--force-recreate` |               |           | Recreate containers even if their configuration and image haven't changed.                    |
-| `--no-build`       |               |           | Don't build an image, even if it's missing.                                                   |
-| `--no-recreate`    |               |           | If containers already exist, don't recreate them. Incompatible with --force-recreate.         |
-| `--pull`           | `string`      | `missing` | Pull image before running ("always"\|"missing"\|"never")                                      |
-| `--remove-orphans` |               |           | Remove containers for services not defined in the Compose file.                               |
-| `--scale`          | `stringArray` |           | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present. |
+| Name               | Type          | Default  | Description                                                                                   |
+|:-------------------|:--------------|:---------|:----------------------------------------------------------------------------------------------|
+| `--build`          |               |          | Build images before starting containers.                                                      |
+| `--dry-run`        |               |          | Execute command in dry run mode                                                               |
+| `--force-recreate` |               |          | Recreate containers even if their configuration and image haven't changed.                    |
+| `--no-build`       |               |          | Don't build an image, even if it's policy.                                                    |
+| `--no-recreate`    |               |          | If containers already exist, don't recreate them. Incompatible with --force-recreate.         |
+| `--pull`           | `string`      | `policy` | Pull image before running ("always"\|"missing"\|"never"\|"build")                             |
+| `--remove-orphans` |               |          | Remove containers for services not defined in the Compose file.                               |
+| `--scale`          | `stringArray` |          | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present. |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_down.md

@@ -22,12 +22,12 @@ Stops containers and removes containers, networks, volumes, and images created b
 
 By default, the only things removed are:
 
-- Containers for services defined in the Compose file
-- Networks defined in the networks section of the Compose file
-- The default network, if one is used
+- Containers for services defined in the Compose file.
+- Networks defined in the networks section of the Compose file.
+- The default network, if one is used.
 
 Networks and volumes defined as external are never removed.
 
-Anonymous volumes are not removed by default. However, as they don’t have a stable name, they will not be automatically
+Anonymous volumes are not removed by default. However, as they don’t have a stable name, they are not automatically
 mounted by a subsequent `up`. For data that needs to persist between updates, use explicit paths as bind mounts or
 named volumes.

docs/reference/compose_events.md

@@ -33,4 +33,4 @@ With the `--json` flag, a json object is printed one per line with the format:
 }
 ```
 
-The events that can be received using this can be seen [here](https://docs.docker.com/engine/reference/commandline/events/#object-types).
+The events that can be received using this can be seen [here](https://docs.docker.com/engine/reference/commandline/system_events/#object-types).

docs/reference/compose_logs.md

@@ -9,6 +9,7 @@ View output from containers
 |:---------------------|:---------|:--------|:-----------------------------------------------------------------------------------------------|
 | `--dry-run`          |          |         | Execute command in dry run mode                                                                |
 | `-f`, `--follow`     |          |         | Follow log output.                                                                             |
+| `--index`            | `int`    | `0`     | index of the container if service has multiple replicas                                        |
 | `--no-color`         |          |         | Produce monochrome output.                                                                     |
 | `--no-log-prefix`    |          |         | Don't print prefix in logs.                                                                    |
 | `--since`            | `string` |         | Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)    |

docs/reference/compose_ps.md

@@ -5,15 +5,17 @@ List containers
 
 ### Options
 
-| Name                  | Type          | Default | Description                                                                                                   |
-|:----------------------|:--------------|:--------|:--------------------------------------------------------------------------------------------------------------|
-| `-a`, `--all`         |               |         | Show all stopped containers (including those created by the run command)                                      |
-| `--dry-run`           |               |         | Execute command in dry run mode                                                                               |
-| [`--filter`](#filter) | `string`      |         | Filter services by a property (supported filters: status).                                                    |
-| [`--format`](#format) | `string`      | `table` | Format the output. Values: [table \| json]                                                                    |
-| `-q`, `--quiet`       |               |         | Only display IDs                                                                                              |
-| `--services`          |               |         | Display services                                                                                              |
-| [`--status`](#status) | `stringArray` |         | Filter services by status. Values: [paused \| restarting \| removing \| running \| dead \| created \| exited] |
+| Name                  | Type          | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                          |
+|:----------------------|:--------------|:--------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `-a`, `--all`         |               |         | Show all stopped containers (including those created by the run command)                                                                                                                                                                                                                                                                                                                                                             |
+| `--dry-run`           |               |         | Execute command in dry run mode                                                                                                                                                                                                                                                                                                                                                                                                      |
+| [`--filter`](#filter) | `string`      |         | Filter services by a property (supported filters: status).                                                                                                                                                                                                                                                                                                                                                                           |
+| [`--format`](#format) | `string`      | `table` | Format output using a custom template:<br>'table':            Print output in table format with column headers (default)<br>'table TEMPLATE':   Print output in table format using the given Go template<br>'json':             Print in JSON format<br>'TEMPLATE':         Print output using the given Go template.<br>Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates |
+| `--no-trunc`          |               |         | Don't truncate output                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `--orphans`           |               |         | Include orphaned services (not declared by project)                                                                                                                                                                                                                                                                                                                                                                                  |
+| `-q`, `--quiet`       |               |         | Only display IDs                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `--services`          |               |         | Display services                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| [`--status`](#status) | `stringArray` |         | Filter services by status. Values: [paused \| restarting \| removing \| running \| dead \| created \| exited]                                                                                                                                                                                                                                                                                                                        |
 
 
 <!---MARKER_GEN_END-->
@@ -28,7 +30,7 @@ NAME            IMAGE     COMMAND           SERVICE    CREATED         STATUS
 example-foo-1   alpine    "/entrypoint.…"   foo        4 seconds ago   Up 2 seconds    0.0.0.0:8080->80/tcp
 ```
 
-By default, only running containers are shown. `--all` flag can be used to include stopped containers
+By default, only running containers are shown. `--all` flag can be used to include stopped containers.
 
 ```console
 $ docker compose ps --all
@@ -52,7 +54,7 @@ $ docker compose ps --format json
 ```
 
 The JSON output allows you to use the information in other tools for further
-processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/){:target="_blank" rel="noopener" class="_"}
+processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/)
 to pretty-print the JSON:
 
 ```console

docs/reference/compose_pull.md

@@ -5,13 +5,14 @@ Pull service images
 
 ### Options
 
-| Name                     | Type | Default | Description                                             |
-|:-------------------------|:-----|:--------|:--------------------------------------------------------|
-| `--dry-run`              |      |         | Execute command in dry run mode                         |
-| `--ignore-buildable`     |      |         | Ignore images that can be built.                        |
-| `--ignore-pull-failures` |      |         | Pull what it can and ignores images with pull failures. |
-| `--include-deps`         |      |         | Also pull services declared as dependencies.            |
-| `-q`, `--quiet`          |      |         | Pull without printing progress information.             |
+| Name                     | Type     | Default | Description                                             |
+|:-------------------------|:---------|:--------|:--------------------------------------------------------|
+| `--dry-run`              |          |         | Execute command in dry run mode                         |
+| `--ignore-buildable`     |          |         | Ignore images that can be built.                        |
+| `--ignore-pull-failures` |          |         | Pull what it can and ignores images with pull failures. |
+| `--include-deps`         |          |         | Also pull services declared as dependencies.            |
+| `--policy`               | `string` |         | Apply pull policy ("missing"\|"always").                |
+| `-q`, `--quiet`          |          |         | Pull without printing progress information.             |
 
 
 <!---MARKER_GEN_END-->
@@ -24,7 +25,7 @@ those images.
 
 ## Examples
 
-suppose you have this `compose.yaml`:
+Consider the following `compose.yaml`:
 
 ```yaml
 services:
@@ -65,5 +66,4 @@ $ docker compose pull db
    ⠹ c8752d5b785c Waiting                                                  9.3s
 ```
 
-`docker compose pull` will try to pull image for services with a build section. If pull fails, it will let
-user know this service image MUST be built. You can skip this by setting `--ignore-buildable` flag
+`docker compose pull` tries to pull image for services with a build section. If pull fails, it lets you know this service image must be built. You can skip this by setting `--ignore-buildable` flag.

docs/reference/compose_restart.md

@@ -23,6 +23,6 @@ after running this command. For example, changes to environment variables (which
 after a container is built, but before the container's command is executed) are not updated
 after restarting.
 
-If you are looking to configure a service's restart policy, please refer to
+If you are looking to configure a service's restart policy, refer to
 [restart](https://github.com/compose-spec/compose-spec/blob/master/spec.md#restart)
 or [restart_policy](https://github.com/compose-spec/compose-spec/blob/master/deploy.md#restart_policy).

docs/reference/compose_run.md

@@ -5,29 +5,29 @@ Run a one-off command on a service.
 
 ### Options
 
-| Name                  | Type          | Default | Description                                                                       |
-|:----------------------|:--------------|:--------|:----------------------------------------------------------------------------------|
-| `--build`             |               |         | Build image before starting container.                                            |
-| `--cap-add`           | `list`        |         | Add Linux capabilities                                                            |
-| `--cap-drop`          | `list`        |         | Drop Linux capabilities                                                           |
-| `-d`, `--detach`      |               |         | Run container in background and print container ID                                |
-| `--dry-run`           |               |         | Execute command in dry run mode                                                   |
-| `--entrypoint`        | `string`      |         | Override the entrypoint of the image                                              |
-| `-e`, `--env`         | `stringArray` |         | Set environment variables                                                         |
-| `-i`, `--interactive` |               |         | Keep STDIN open even if not attached.                                             |
-| `-l`, `--label`       | `stringArray` |         | Add or override a label                                                           |
-| `--name`              | `string`      |         | Assign a name to the container                                                    |
-| `-T`, `--no-TTY`      |               |         | Disable pseudo-TTY allocation (default: auto-detected).                           |
-| `--no-deps`           |               |         | Don't start linked services.                                                      |
-| `-p`, `--publish`     | `stringArray` |         | Publish a container's port(s) to the host.                                        |
-| `--quiet-pull`        |               |         | Pull without printing progress information.                                       |
-| `--remove-orphans`    |               |         | Remove containers for services not defined in the Compose file.                   |
-| `--rm`                |               |         | Automatically remove the container when it exits                                  |
-| `--service-ports`     |               |         | Run command with the service's ports enabled and mapped to the host.              |
-| `--use-aliases`       |               |         | Use the service's network useAliases in the network(s) the container connects to. |
-| `-u`, `--user`        | `string`      |         | Run as specified username or uid                                                  |
-| `-v`, `--volume`      | `stringArray` |         | Bind mount a volume.                                                              |
-| `-w`, `--workdir`     | `string`      |         | Working directory inside the container                                            |
+| Name                    | Type          | Default | Description                                                                       |
+|:------------------------|:--------------|:--------|:----------------------------------------------------------------------------------|
+| `--build`               |               |         | Build image before starting container.                                            |
+| `--cap-add`             | `list`        |         | Add Linux capabilities                                                            |
+| `--cap-drop`            | `list`        |         | Drop Linux capabilities                                                           |
+| `-d`, `--detach`        |               |         | Run container in background and print container ID                                |
+| `--dry-run`             |               |         | Execute command in dry run mode                                                   |
+| `--entrypoint`          | `string`      |         | Override the entrypoint of the image                                              |
+| `-e`, `--env`           | `stringArray` |         | Set environment variables                                                         |
+| `-i`, `--interactive`   |               |         | Keep STDIN open even if not attached.                                             |
+| `-l`, `--label`         | `stringArray` |         | Add or override a label                                                           |
+| `--name`                | `string`      |         | Assign a name to the container                                                    |
+| `-T`, `--no-TTY`        |               |         | Disable pseudo-TTY allocation (default: auto-detected).                           |
+| `--no-deps`             |               |         | Don't start linked services.                                                      |
+| `-p`, `--publish`       | `stringArray` |         | Publish a container's port(s) to the host.                                        |
+| `--quiet-pull`          |               |         | Pull without printing progress information.                                       |
+| `--remove-orphans`      |               |         | Remove containers for services not defined in the Compose file.                   |
+| `--rm`                  |               |         | Automatically remove the container when it exits                                  |
+| `-P`, `--service-ports` |               |         | Run command with all service's ports enabled and mapped to the host.              |
+| `--use-aliases`         |               |         | Use the service's network useAliases in the network(s) the container connects to. |
+| `-u`, `--user`          | `string`      |         | Run as specified username or uid                                                  |
+| `-v`, `--volume`        | `stringArray` |         | Bind mount a volume.                                                              |
+| `-w`, `--workdir`       | `string`      |         | Working directory inside the container                                            |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_scale.md

@@ -0,0 +1,15 @@
+# docker compose scale
+
+<!---MARKER_GEN_START-->
+Scale services 
+
+### Options
+
+| Name        | Type | Default | Description                     |
+|:------------|:-----|:--------|:--------------------------------|
+| `--dry-run` |      |         | Execute command in dry run mode |
+| `--no-deps` |      |         | Don't start linked services.    |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/compose_stats.md

@@ -0,0 +1,18 @@
+# docker compose stats
+
+<!---MARKER_GEN_START-->
+Display a live stream of container(s) resource usage statistics
+
+### Options
+
+| Name          | Type     | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                          |
+|:--------------|:---------|:--------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `-a`, `--all` |          |         | Show all containers (default shows just running)                                                                                                                                                                                                                                                                                                                                                                                     |
+| `--dry-run`   |          |         | Execute command in dry run mode                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `--format`    | `string` |         | Format output using a custom template:<br>'table':            Print output in table format with column headers (default)<br>'table TEMPLATE':   Print output in table format using the given Go template<br>'json':             Print in JSON format<br>'TEMPLATE':         Print output using the given Go template.<br>Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates |
+| `--no-stream` |          |         | Disable streaming stats and only pull the first result                                                                                                                                                                                                                                                                                                                                                                               |
+| `--no-trunc`  |          |         | Do not truncate output                                                                                                                                                                                                                                                                                                                                                                                                               |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/compose_up.md

@@ -5,33 +5,33 @@ Create and start containers
 
 ### Options
 
-| Name                         | Type          | Default   | Description                                                                                              |
-|:-----------------------------|:--------------|:----------|:---------------------------------------------------------------------------------------------------------|
-| `--abort-on-container-exit`  |               |           | Stops all containers if any container was stopped. Incompatible with -d                                  |
-| `--always-recreate-deps`     |               |           | Recreate dependent containers. Incompatible with --no-recreate.                                          |
-| `--attach`                   | `stringArray` |           | Attach to service output.                                                                                |
-| `--attach-dependencies`      |               |           | Attach to dependent containers.                                                                          |
-| `--build`                    |               |           | Build images before starting containers.                                                                 |
-| `-d`, `--detach`             |               |           | Detached mode: Run containers in the background                                                          |
-| `--dry-run`                  |               |           | Execute command in dry run mode                                                                          |
-| `--exit-code-from`           | `string`      |           | Return the exit code of the selected service container. Implies --abort-on-container-exit                |
-| `--force-recreate`           |               |           | Recreate containers even if their configuration and image haven't changed.                               |
-| `--no-attach`                | `stringArray` |           | Don't attach to specified service.                                                                       |
-| `--no-build`                 |               |           | Don't build an image, even if it's missing.                                                              |
-| `--no-color`                 |               |           | Produce monochrome output.                                                                               |
-| `--no-deps`                  |               |           | Don't start linked services.                                                                             |
-| `--no-log-prefix`            |               |           | Don't print prefix in logs.                                                                              |
-| `--no-recreate`              |               |           | If containers already exist, don't recreate them. Incompatible with --force-recreate.                    |
-| `--no-start`                 |               |           | Don't start the services after creating them.                                                            |
-| `--pull`                     | `string`      | `missing` | Pull image before running ("always"\|"missing"\|"never")                                                 |
-| `--quiet-pull`               |               |           | Pull without printing progress information.                                                              |
-| `--remove-orphans`           |               |           | Remove containers for services not defined in the Compose file.                                          |
-| `-V`, `--renew-anon-volumes` |               |           | Recreate anonymous volumes instead of retrieving data from the previous containers.                      |
-| `--scale`                    | `stringArray` |           | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present.            |
-| `-t`, `--timeout`            | `int`         | `0`       | Use this timeout in seconds for container shutdown when attached or when containers are already running. |
-| `--timestamps`               |               |           | Show timestamps.                                                                                         |
-| `--wait`                     |               |           | Wait for services to be running\|healthy. Implies detached mode.                                         |
-| `--wait-timeout`             | `int`         | `0`       | timeout waiting for application to be running\|healthy.                                                  |
+| Name                         | Type          | Default  | Description                                                                                              |
+|:-----------------------------|:--------------|:---------|:---------------------------------------------------------------------------------------------------------|
+| `--abort-on-container-exit`  |               |          | Stops all containers if any container was stopped. Incompatible with -d                                  |
+| `--always-recreate-deps`     |               |          | Recreate dependent containers. Incompatible with --no-recreate.                                          |
+| `--attach`                   | `stringArray` |          | Restrict attaching to the specified services. Incompatible with --attach-dependencies.                   |
+| `--attach-dependencies`      |               |          | Automatically attach to log output of dependent services.                                                |
+| `--build`                    |               |          | Build images before starting containers.                                                                 |
+| `-d`, `--detach`             |               |          | Detached mode: Run containers in the background                                                          |
+| `--dry-run`                  |               |          | Execute command in dry run mode                                                                          |
+| `--exit-code-from`           | `string`      |          | Return the exit code of the selected service container. Implies --abort-on-container-exit                |
+| `--force-recreate`           |               |          | Recreate containers even if their configuration and image haven't changed.                               |
+| `--no-attach`                | `stringArray` |          | Do not attach (stream logs) to the specified services.                                                   |
+| `--no-build`                 |               |          | Don't build an image, even if it's policy.                                                               |
+| `--no-color`                 |               |          | Produce monochrome output.                                                                               |
+| `--no-deps`                  |               |          | Don't start linked services.                                                                             |
+| `--no-log-prefix`            |               |          | Don't print prefix in logs.                                                                              |
+| `--no-recreate`              |               |          | If containers already exist, don't recreate them. Incompatible with --force-recreate.                    |
+| `--no-start`                 |               |          | Don't start the services after creating them.                                                            |
+| `--pull`                     | `string`      | `policy` | Pull image before running ("always"\|"missing"\|"never")                                                 |
+| `--quiet-pull`               |               |          | Pull without printing progress information.                                                              |
+| `--remove-orphans`           |               |          | Remove containers for services not defined in the Compose file.                                          |
+| `-V`, `--renew-anon-volumes` |               |          | Recreate anonymous volumes instead of retrieving data from the previous containers.                      |
+| `--scale`                    | `stringArray` |          | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present.            |
+| `-t`, `--timeout`            | `int`         | `0`      | Use this timeout in seconds for container shutdown when attached or when containers are already running. |
+| `--timestamps`               |               |          | Show timestamps.                                                                                         |
+| `--wait`                     |               |          | Wait for services to be running\|healthy. Implies detached mode.                                         |
+| `--wait-timeout`             | `int`         | `0`      | Maximum duration to wait for the project to be running\|healthy.                                         |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_watch.md

@@ -0,0 +1,16 @@
+# docker compose watch
+
+<!---MARKER_GEN_START-->
+Watch build context for service and rebuild/refresh containers when files are updated
+
+### Options
+
+| Name        | Type | Default | Description                                   |
+|:------------|:-----|:--------|:----------------------------------------------|
+| `--dry-run` |      |         | Execute command in dry run mode               |
+| `--no-up`   |      |         | Do not build & start services before watching |
+| `--quiet`   |      |         | hide build output                             |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/docker_compose.yaml

@@ -1,7 +1,7 @@
 command: docker compose
 short: Docker Compose
 long: |-
-    You can use compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
+    You can use the compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
     multiple services in Docker containers.
 
     ### Use `-f` to specify the name and path of one or more Compose files
@@ -90,16 +90,16 @@ long: |-
     ### Use profiles to enable optional services
 
     Use `--profile` to specify one or more active profiles
-    Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services
+    Calling `docker compose --profile frontend up` starts the services with the profile `frontend` and services
     without any specified profiles.
-    You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` will be enabled.
+    You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` is enabled.
 
     Profiles can also be set by `COMPOSE_PROFILES` environment variable.
 
     ### Configuring parallelism
 
     Use `--parallel` to specify the maximum level of parallelism for concurrent engine calls.
-    Calling `docker compose --parallel 1 pull` will pull the pullable images defined in the Compose file
+    Calling `docker compose --parallel 1 pull` pulls the pullable images defined in the Compose file
     one at a time. This can also be used to control build concurrency.
 
     Parallelism can also be set by the `COMPOSE_PARALLEL_LIMIT` environment variable.
@@ -115,7 +115,7 @@ long: |-
 
     If flags are explicitly set on the command line, the associated environment variable is ignored.
 
-    Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` will stop docker compose from detecting orphaned
+    Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` stops docker compose from detecting orphaned
     containers for the project.
 
     ### Use Dry Run mode to test your command
@@ -146,6 +146,7 @@ usage: docker compose
 pname: docker
 plink: docker.yaml
 cname:
+    - docker compose attach
     - docker compose build
     - docker compose config
     - docker compose cp
@@ -165,14 +166,18 @@ cname:
     - docker compose restart
     - docker compose rm
     - docker compose run
+    - docker compose scale
     - docker compose start
+    - docker compose stats
     - docker compose stop
     - docker compose top
     - docker compose unpause
     - docker compose up
     - docker compose version
     - docker compose wait
+    - docker compose watch
 clink:
+    - docker_compose_attach.yaml
     - docker_compose_build.yaml
     - docker_compose_config.yaml
     - docker_compose_cp.yaml
@@ -192,13 +197,16 @@ clink:
     - docker_compose_restart.yaml
     - docker_compose_rm.yaml
     - docker_compose_run.yaml
+    - docker_compose_scale.yaml
     - docker_compose_start.yaml
+    - docker_compose_stats.yaml
     - docker_compose_stop.yaml
     - docker_compose_top.yaml
     - docker_compose_unpause.yaml
     - docker_compose_up.yaml
     - docker_compose_version.yaml
     - docker_compose_wait.yaml
+    - docker_compose_watch.yaml
 options:
     - option: ansi
       value_type: string

docs/reference/docker_compose_alpha.yaml

@@ -4,11 +4,11 @@ long: Experimental commands
 pname: docker compose
 plink: docker_compose.yaml
 cname:
+    - docker compose alpha publish
     - docker compose alpha viz
-    - docker compose alpha watch
 clink:
+    - docker_compose_alpha_publish.yaml
     - docker_compose_alpha_viz.yaml
-    - docker_compose_alpha_watch.yaml
 inherited_options:
     - option: dry-run
       value_type: bool

docs/reference/docker_compose_alpha_publish.yaml

@@ -0,0 +1,45 @@
+command: docker compose alpha publish
+short: Publish compose application
+long: Publish compose application
+usage: docker compose alpha publish [OPTIONS] [REPOSITORY]
+pname: docker compose alpha
+plink: docker_compose_alpha.yaml
+options:
+    - option: oci-version
+      value_type: string
+      description: |
+        OCI Image/Artifact specification version (automatically determined by default)
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: resolve-image-digests
+      value_type: bool
+      default_value: "false"
+      description: Pin image tags to digests.
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: true
+kubernetes: false
+swarm: false
+

docs/reference/docker_compose_alpha_scale.yaml

@@ -0,0 +1,35 @@
+command: docker compose alpha scale
+short: Scale services
+long: Scale services
+usage: docker compose alpha scale [SERVICE=REPLICAS...]
+pname: docker compose alpha
+plink: docker_compose_alpha.yaml
+options:
+    - option: no-deps
+      value_type: bool
+      default_value: "false"
+      description: Don't start linked services.
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: true
+kubernetes: false
+swarm: false
+

docs/reference/docker_compose_alpha_watch.yaml

@@ -1,12 +1,22 @@
 command: docker compose alpha watch
 short: |
-    EXPERIMENTAL - Watch build context for service and rebuild/refresh containers when files are updated
+    Watch build context for service and rebuild/refresh containers when files are updated
 long: |
-    EXPERIMENTAL - Watch build context for service and rebuild/refresh containers when files are updated
+    Watch build context for service and rebuild/refresh containers when files are updated
 usage: docker compose alpha watch [SERVICE...]
 pname: docker compose alpha
 plink: docker_compose_alpha.yaml
 options:
+    - option: no-up
+      value_type: bool
+      default_value: "false"
+      description: Do not build & start services before watching
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
     - option: quiet
       value_type: bool
       default_value: "false"

docs/reference/docker_compose_attach.yaml

@@ -0,0 +1,66 @@
+command: docker compose attach
+short: |
+    Attach local standard input, output, and error streams to a service's running container.
+long: |
+    Attach local standard input, output, and error streams to a service's running container.
+usage: docker compose attach [OPTIONS] SERVICE
+pname: docker compose
+plink: docker_compose.yaml
+options:
+    - option: detach-keys
+      value_type: string
+      description: Override the key sequence for detaching from a container.
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: index
+      value_type: int
+      default_value: "0"
+      description: index of the container if service has multiple replicas.
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: no-stdin
+      value_type: bool
+      default_value: "false"
+      description: Do not attach STDIN
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: sig-proxy
+      value_type: bool
+      default_value: "true"
+      description: Proxy all received signals to the process
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: false
+kubernetes: false
+swarm: false
+

docs/reference/docker_compose_build.yaml

@@ -147,6 +147,16 @@ options:
       experimentalcli: false
       kubernetes: false
       swarm: false
+    - option: with-dependencies
+      value_type: bool
+      default_value: "false"
+      description: Also build dependencies (transitively).
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
 inherited_options:
     - option: dry-run
       value_type: bool

docs/reference/docker_compose_config.yaml

@@ -2,8 +2,8 @@ command: docker compose config
 aliases: docker compose config, docker compose convert
 short: Parse, resolve and render compose file in canonical format
 long: |-
-    `docker compose config` renders the actual data model to be applied on the Docker engine.
-    it merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
+    `docker compose config` renders the actual data model to be applied on the Docker Engine.
+    It merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
     the canonical format.
 usage: docker compose config [OPTIONS] [SERVICE...]
 pname: docker compose

docs/reference/docker_compose_create.yaml

@@ -29,7 +29,7 @@ options:
     - option: no-build
       value_type: bool
       default_value: "false"
-      description: Don't build an image, even if it's missing.
+      description: Don't build an image, even if it's policy.
       deprecated: false
       hidden: false
       experimental: false
@@ -49,8 +49,8 @@ options:
       swarm: false
     - option: pull
       value_type: string
-      default_value: missing
-      description: Pull image before running ("always"|"missing"|"never")
+      default_value: policy
+      description: Pull image before running ("always"|"missing"|"never"|"build")
       deprecated: false
       hidden: false
       experimental: false

docs/reference/docker_compose_down.yaml

@@ -5,13 +5,13 @@ long: |-
 
     By default, the only things removed are:
 
-    - Containers for services defined in the Compose file
-    - Networks defined in the networks section of the Compose file
-    - The default network, if one is used
+    - Containers for services defined in the Compose file.
+    - Networks defined in the networks section of the Compose file.
+    - The default network, if one is used.
 
     Networks and volumes defined as external are never removed.
 
-    Anonymous volumes are not removed by default. However, as they don’t have a stable name, they will not be automatically
+    Anonymous volumes are not removed by default. However, as they don’t have a stable name, they are not automatically
     mounted by a subsequent `up`. For data that needs to persist between updates, use explicit paths as bind mounts or
     named volumes.
 usage: docker compose down [OPTIONS] [SERVICES]

docs/reference/docker_compose_events.yaml

@@ -19,7 +19,7 @@ long: |-
     }
     ```
 
-    The events that can be received using this can be seen [here](/engine/reference/commandline/events/#object-types).
+    The events that can be received using this can be seen [here](/engine/reference/commandline/system_events/#object-types).
 usage: docker compose events [OPTIONS] [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml

docs/reference/docker_compose_logs.yaml

@@ -16,6 +16,16 @@ options:
       experimentalcli: false
       kubernetes: false
       swarm: false
+    - option: index
+      value_type: int
+      default_value: "0"
+      description: index of the container if service has multiple replicas
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
     - option: no-color
       value_type: bool
       default_value: "false"

docs/reference/docker_compose_ps.yaml

@@ -9,7 +9,7 @@ long: |-
     example-foo-1   alpine    "/entrypoint.…"   foo        4 seconds ago   Up 2 seconds    0.0.0.0:8080->80/tcp
     ```
 
-    By default, only running containers are shown. `--all` flag can be used to include stopped containers
+    By default, only running containers are shown. `--all` flag can be used to include stopped containers.
 
     ```console
     $ docker compose ps --all
@@ -46,7 +46,13 @@ options:
     - option: format
       value_type: string
       default_value: table
-      description: 'Format the output. Values: [table | json]'
+      description: |-
+        Format output using a custom template:
+        'table':            Print output in table format with column headers (default)
+        'table TEMPLATE':   Print output in table format using the given Go template
+        'json':             Print in JSON format
+        'TEMPLATE':         Print output using the given Go template.
+        Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
       details_url: '#format'
       deprecated: false
       hidden: false
@@ -54,6 +60,26 @@ options:
       experimentalcli: false
       kubernetes: false
       swarm: false
+    - option: no-trunc
+      value_type: bool
+      default_value: "false"
+      description: Don't truncate output
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: orphans
+      value_type: bool
+      default_value: "true"
+      description: Include orphaned services (not declared by project)
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
     - option: quiet
       shorthand: q
       value_type: bool
@@ -112,7 +138,7 @@ examples: |-
     ```
 
     The JSON output allows you to use the information in other tools for further
-    processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/){:target="_blank" rel="noopener" class="_"}
+    processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/)
     to pretty-print the JSON:
 
     ```console

docs/reference/docker_compose_pull.yaml

@@ -57,6 +57,15 @@ options:
       experimentalcli: false
       kubernetes: false
       swarm: false
+    - option: policy
+      value_type: string
+      description: Apply pull policy ("missing"|"always").
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
     - option: quiet
       shorthand: q
       value_type: bool
@@ -80,7 +89,7 @@ inherited_options:
       kubernetes: false
       swarm: false
 examples: |-
-    suppose you have this `compose.yaml`:
+    Consider the following `compose.yaml`:
 
     ```yaml
     services:
@@ -121,8 +130,7 @@ examples: |-
        ⠹ c8752d5b785c Waiting                                                  9.3s
     ```
 
-    `docker compose pull` will try to pull image for services with a build section. If pull fails, it will let
-    user know this service image MUST be built. You can skip this by setting `--ignore-buildable` flag
+    `docker compose pull` tries to pull image for services with a build section. If pull fails, it lets you know this service image must be built. You can skip this by setting `--ignore-buildable` flag.
 deprecated: false
 hidden: false
 experimental: false

docs/reference/docker_compose_restart.yaml

@@ -8,7 +8,7 @@ long: |-
     after a container is built, but before the container's command is executed) are not updated
     after restarting.
 
-    If you are looking to configure a service's restart policy, please refer to
+    If you are looking to configure a service's restart policy, refer to
     [restart](https://github.com/compose-spec/compose-spec/blob/master/spec.md#restart)
     or [restart_policy](https://github.com/compose-spec/compose-spec/blob/master/deploy.md#restart_policy).
 usage: docker compose restart [OPTIONS] [SERVICE...]

docs/reference/docker_compose_run.yaml

@@ -211,10 +211,11 @@ options:
       kubernetes: false
       swarm: false
     - option: service-ports
+      shorthand: P
       value_type: bool
       default_value: "false"
       description: |
-        Run command with the service's ports enabled and mapped to the host.
+        Run command with all service's ports enabled and mapped to the host.
       deprecated: false
       hidden: false
       experimental: false

docs/reference/docker_compose_scale.yaml

@@ -0,0 +1,35 @@
+command: docker compose scale
+short: Scale services
+long: Scale services
+usage: docker compose scale [SERVICE=REPLICAS...]
+pname: docker compose
+plink: docker_compose.yaml
+options:
+    - option: no-deps
+      value_type: bool
+      default_value: "false"
+      description: Don't start linked services.
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: false
+kubernetes: false
+swarm: false
+

docs/reference/docker_compose_stats.yaml

@@ -0,0 +1,71 @@
+command: docker compose stats
+short: Display a live stream of container(s) resource usage statistics
+long: Display a live stream of container(s) resource usage statistics
+usage: docker compose stats [OPTIONS] [SERVICE]
+pname: docker compose
+plink: docker_compose.yaml
+options:
+    - option: all
+      shorthand: a
+      value_type: bool
+      default_value: "false"
+      description: Show all containers (default shows just running)
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: format
+      value_type: string
+      description: |-
+        Format output using a custom template:
+        'table':            Print output in table format with column headers (default)
+        'table TEMPLATE':   Print output in table format using the given Go template
+        'json':             Print in JSON format
+        'TEMPLATE':         Print output using the given Go template.
+        Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: no-stream
+      value_type: bool
+      default_value: "false"
+      description: Disable streaming stats and only pull the first result
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: no-trunc
+      value_type: bool
+      default_value: "false"
+      description: Do not truncate output
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: false
+kubernetes: false
+swarm: false
+

docs/reference/docker_compose_up.yaml

@@ -48,7 +48,8 @@ options:
     - option: attach
       value_type: stringArray
       default_value: '[]'
-      description: Attach to service output.
+      description: |
+        Restrict attaching to the specified services. Incompatible with --attach-dependencies.
       deprecated: false
       hidden: false
       experimental: false
@@ -58,7 +59,7 @@ options:
     - option: attach-dependencies
       value_type: bool
       default_value: "false"
-      description: Attach to dependent containers.
+      description: Automatically attach to log output of dependent services.
       deprecated: false
       hidden: false
       experimental: false
@@ -110,7 +111,7 @@ options:
     - option: no-attach
       value_type: stringArray
       default_value: '[]'
-      description: Don't attach to specified service.
+      description: Do not attach (stream logs) to the specified services.
       deprecated: false
       hidden: false
       experimental: false
@@ -120,7 +121,7 @@ options:
     - option: no-build
       value_type: bool
       default_value: "false"
-      description: Don't build an image, even if it's missing.
+      description: Don't build an image, even if it's policy.
       deprecated: false
       hidden: false
       experimental: false
@@ -180,7 +181,7 @@ options:
       swarm: false
     - option: pull
       value_type: string
-      default_value: missing
+      default_value: policy
       description: Pull image before running ("always"|"missing"|"never")
       deprecated: false
       hidden: false
@@ -266,7 +267,7 @@ options:
     - option: wait-timeout
       value_type: int
       default_value: "0"
-      description: timeout waiting for application to be running|healthy.
+      description: Maximum duration to wait for the project to be running|healthy.
       deprecated: false
       hidden: false
       experimental: false

docs/reference/docker_compose_watch.yaml

@@ -0,0 +1,47 @@
+command: docker compose watch
+short: |
+    Watch build context for service and rebuild/refresh containers when files are updated
+long: |
+    Watch build context for service and rebuild/refresh containers when files are updated
+usage: docker compose watch [SERVICE...]
+pname: docker compose
+plink: docker_compose.yaml
+options:
+    - option: no-up
+      value_type: bool
+      default_value: "false"
+      description: Do not build & start services before watching
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+    - option: quiet
+      value_type: bool
+      default_value: "false"
+      description: hide build output
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+inherited_options:
+    - option: dry-run
+      value_type: bool
+      default_value: "false"
+      description: Execute command in dry run mode
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: false
+kubernetes: false
+swarm: false
+

e2e/cucumber-features/build-contexts.feature

@@ -1,21 +0,0 @@
-Feature: Build Contexts
-
-Background:
-    Given a compose file
-        """
-        services:
-          a:
-            build:
-                context: .
-                dockerfile_inline: |
-                    # syntax=docker/dockerfile:1
-                    FROM alpine:latest
-                    COPY --from=dep /etc/hostname /
-                additional_contexts:
-                  - dep=docker-image://ubuntu:latest
-        """
-
-Scenario: Build w/ build context
-    When I run "compose build"
-    Then the exit code is 0
-

e2e/cucumber-features/down.feature

@@ -1,5 +0,0 @@
-Feature: Down
-
-Scenario: No resources to remove
-    When I run "compose down"
-    Then the output contains "Warning: No resource found to remove for project "no_resources_to_remove""

e2e/cucumber-features/port-conflict.feature

@@ -1,28 +0,0 @@
-Feature: Report port conflicts
-
-Background:
-    Given a compose file
-        """
-        services:
-          web:
-            image: nginx
-            ports:
-            - 31415:80
-        """
-    And I run "docker rm -f nginx-pi-31415"
-
-Scenario: Reports a port allocation conflict with another container
-    Given I run "docker run -d -p 31415:80 --name nginx-pi-31415 nginx"
-    When I run "compose up -d"
-    Then the output contains "port is already allocated"
-    And the exit code is 1
-
-Scenario: Reports a port conflict with some other process
-    Given a process listening on port 31415
-    When I run "compose up -d"
-    Then the output contains "address already in use"
-    And the exit code is 1
-
-Scenario: Cleanup
-    Given I run "docker rm -f nginx-pi-31415"
-

e2e/cucumber-features/ps.feature

@@ -1,29 +0,0 @@
-Feature: PS
-
-Background:
-    Given a compose file
-        """
-        services:
-          build:
-            image: test:latest
-            build:
-                context: ./
-          pull:
-            image: alpine
-            command: top
-        """
-    And a dockerfile
-        """
-        FROM golang:1.19-alpine
-        """
-    And I run "docker rm -f external-test"
-
-Scenario: external container from compose image exists
-    When I run "compose build"
-    Then the exit code is 0
-    And I run "docker run --name external-test test:latest ls"
-    Then the exit code is 0
-    And I run "compose ps -a"
-    Then the output does not contain "external-test"
-    And I run "docker rm -f external-test"
-

e2e/cucumber-features/simple.feature

@@ -1,15 +0,0 @@
-Feature: Simple service up
-
-Background:
-    Given a compose file
-        """
-        services:
-          simple:
-            image: alpine
-            command: top
-        """
-
-Scenario: compose up
-    When I run "compose up -d"
-    Then the output contains "simple-1  Started"
-    And service "simple" is "Up"