cmd

Documentation

Index

• Variables

Variables

var (

	// Config : docker inaccel config
	Config = &cobra.Command{
		Use:   "config [OPTIONS]",
		Short: "Validate and view the config file",
		Args:  cobra.NoArgs,
		RunE: func(_ *cobra.Command, _ []string) error {
			rootless, err := internal.Rootless()
			if err != nil {
				return err
			}

			var cmd *system.Cmd

			if viper.GetBool("pull") {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("pull")
				cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
				cmd.Std(nil, os.Stdout, os.Stderr)

				if err := cmd.Run(viper.GetBool("debug")); err != nil {
					return internal.ExitToStatus(err)
				}
			}

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("run")
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_PATH", internal.Host.Path))
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_SCHEME", internal.Host.Scheme))
			if rootless {
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CACHE_HOME", xdg.CacheHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_DIRS", strings.Join(xdg.ConfigDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_HOME", xdg.ConfigHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_DIRS", strings.Join(xdg.DataDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_HOME", xdg.DataHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_RUNTIME_DIR", xdg.RuntimeDir))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_STATE_HOME", xdg.StateHome))
			}
			cmd.Flag("env", viper.GetStringSlice("env"))
			if len(viper.GetString("env-file")) > 0 {
				cmd.Flag("env-file", viper.GetString("env-file"))
			} else if _, err := os.Stat(".env"); err == nil {
				cmd.Flag("env-file", ".env")
			}
			cmd.Flag("interactive", true)
			cmd.Flag("rm", true)
			cmd.Flag("volume", fmt.Sprintf("%s:%s", internal.Host.Path, "/var/run/docker.sock"))
			cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
			if isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd()) {
				cmd.Flag("ansi", "always")
			} else {
				cmd.Flag("ansi", "never")
			}
			cmd.Arg("config")
			cmd.Flag("profiles", config.GetBool("profiles"))
			cmd.Flag("quiet", config.GetBool("quiet"))
			cmd.Flag("resolve-image-digests", config.GetBool("resolve-image-digests"))
			cmd.Flag("services", config.GetBool("services"))
			cmd.Std(nil, os.Stdout, os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)

var (

	// Down : docker inaccel down
	Down = &cobra.Command{
		Use:   "down [OPTIONS] [SERVICE]",
		Short: "Stop and remove containers and networks",
		ValidArgsFunction: func(_ *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
			var cmd *system.Cmd

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Arg("ps")
			cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
			cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
			cmd.Flag("format", `{{ .Label "com.docker.compose.service" }}`)

			out, err := cmd.Out(false)
			if err != nil {
				return nil, cobra.ShellCompDirectiveDefault
			}

			var completions []string
			for _, completion := range strings.Fields(out) {
				if strings.HasPrefix(completion, toComplete) {
					completions = append(completions, completion)
				}
			}
			return completions, cobra.ShellCompDirectiveNoFileComp
		},
		Args: cobra.MaximumNArgs(1),
		PreRunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("ps")
			cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
			cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
			if len(args) > 0 {
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.service=%s", args[0]))
			}
			cmd.Flag("format", `{{ .ID }}`)
			cmd.Std(nil, nil, os.Stderr)

			out, err := cmd.Out(viper.GetBool("debug"))
			if err != nil {
				return internal.ExitToStatus(err)
			}

			ids := strings.Fields(out)

			if len(ids) > 0 {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("stop")
				cmd.Arg(ids...)
				cmd.Std(nil, nil, os.Stderr)

				if err := cmd.Run(viper.GetBool("debug")); err != nil {
					return internal.ExitToStatus(err)
				}
			}

			return nil
		},
		RunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("container", "prune")
			cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
			cmd.Flag("force", true)
			cmd.Std(nil, grep.MustCompile("^$|Total reclaimed space").WriteCloser(os.Stdout, false, true), os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("network", "prune")
			cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
			cmd.Flag("force", true)
			cmd.Std(nil, grep.MustCompile("^$|Total reclaimed space").WriteCloser(os.Stdout, false, true), os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			if down.GetBool("volumes") {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("volume", "ls")
				cmd.Flag("filter", "dangling=true")
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
				cmd.Flag("format", `{{ .Name }}`)
				cmd.Std(nil, nil, os.Stderr)

				out, err := cmd.Out(viper.GetBool("debug"))
				if err != nil {
					return internal.ExitToStatus(err)
				}

				names := strings.Fields(out)

				if len(names) > 0 {
					cmd = system.Command("docker")
					cmd.Flag("host", internal.Host)
					cmd.Flag("log-level", viper.GetString("log-level"))
					cmd.Arg("volume", "rm")
					cmd.Arg(names...)
					cmd.Std(nil, nil, os.Stderr)

					if err := cmd.Run(viper.GetBool("debug")); err != nil {
						return internal.ExitToStatus(err)
					}

					fmt.Fprintln(os.Stdout, "Deleted Volumes:")
					fmt.Fprint(os.Stdout, out)
				}
			}

			return nil
		},
	}
)

var (

	// Exec : docker inaccel exec
	Exec = &cobra.Command{
		Use:   "exec [OPTIONS] COMMAND [ARG...]",
		Short: "Execute a command in a running container",
		Args:  cobra.ArbitraryArgs,
		PreRunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			if len(exec.GetString("service")) == 0 {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("ps")
				cmd.Flag("all", true)
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.container-number=%d", exec.GetInt("index")))
				cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
				cmd.Flag("filter", "label=com.inaccel.docker.default-exec-service=True")
				cmd.Flag("format", `{{ .Label "com.docker.compose.service" }}`)
				cmd.Std(nil, nil, os.Stderr)

				out, err := cmd.Out(viper.GetBool("debug"))
				if err != nil {
					return internal.ExitToStatus(err)
				}

				services := strings.Fields(out)

				if len(services) > 0 {
					exec.Set("service", services[0])
				} else {
					cmd = system.Command("docker")
					cmd.Flag("host", internal.Host)
					cmd.Flag("log-level", viper.GetString("log-level"))
					cmd.Arg("ps")
					cmd.Flag("all", true)
					cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.container-number=%d", exec.GetInt("index")))
					cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
					cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
					cmd.Flag("format", `{{ .Label "com.docker.compose.service" }}`)
					cmd.Std(nil, nil, os.Stderr)

					out, err := cmd.Out(viper.GetBool("debug"))
					if err != nil {
						return internal.ExitToStatus(err)
					}

					services := strings.Fields(out)

					if len(services) == 0 {
						return fmt.Errorf("Error: No service (%d) found for %s", exec.GetInt("index"), viper.GetString("project-name"))
					} else if len(services) == 1 {
						exec.Set("service", services[0])
					} else {
						return fmt.Errorf("Error: A service (%d) must be specified for %s, choose one of: [%s]", exec.GetInt("index"), viper.GetString("project-name"), strings.Join(services, " "))
					}
				}
			}

			return nil
		},
		RunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			if err := cobra.MinimumNArgs(1)(nil, args); err != nil {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("inspect")
				cmd.Flag("format", `{{ index .Config.Labels "com.inaccel.docker.default-exec-command" }}`)
				cmd.Arg(fmt.Sprintf("%s_%s_%d", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_"), exec.GetString("service"), exec.GetInt("index")))
				cmd.Std(nil, nil, os.Stderr)

				out, err := cmd.Out(viper.GetBool("debug"))
				if err != nil {
					return internal.ExitToStatus(err)
				}

				args = strings.Fields(out)

				if err := cobra.MinimumNArgs(1)(nil, args); err != nil {
					return err
				}
			}

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("exec")
			cmd.Flag("env", exec.GetStringSlice("env"))
			cmd.Flag("interactive", true)
			cmd.Flag("tty", !exec.GetBool("no-tty") && isatty.IsTerminal(os.Stdin.Fd()) && isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd()))
			cmd.Flag("user", exec.GetString("user"))
			cmd.Flag("workdir", exec.GetString("workdir"))
			cmd.Arg(fmt.Sprintf("%s_%s_%d", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_"), exec.GetString("service"), exec.GetInt("index")))
			cmd.Arg(args...)
			cmd.Std(os.Stdin, os.Stdout, os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)

var (

	// Logs : docker inaccel logs
	Logs = &cobra.Command{
		Use:   "logs [OPTIONS] [PATTERN]",
		Short: "View output from containers",
		Args:  cobra.MaximumNArgs(1),
		PreRunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			if len(logs.GetString("service")) == 0 {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("ps")
				cmd.Flag("all", true)
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.container-number=%d", logs.GetInt("index")))
				cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
				cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
				cmd.Flag("filter", "label=com.inaccel.docker.default-logs-service=True")
				cmd.Flag("format", `{{ .Label "com.docker.compose.service" }}`)
				cmd.Std(nil, nil, os.Stderr)

				out, err := cmd.Out(viper.GetBool("debug"))
				if err != nil {
					return internal.ExitToStatus(err)
				}

				services := strings.Fields(out)

				if len(services) > 0 {
					logs.Set("service", services[0])
				} else {
					cmd = system.Command("docker")
					cmd.Flag("host", internal.Host)
					cmd.Flag("log-level", viper.GetString("log-level"))
					cmd.Arg("ps")
					cmd.Flag("all", true)
					cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.container-number=%d", logs.GetInt("index")))
					cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
					cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
					cmd.Flag("format", `{{ .Label "com.docker.compose.service" }}`)
					cmd.Std(nil, nil, os.Stderr)

					out, err := cmd.Out(viper.GetBool("debug"))
					if err != nil {
						return internal.ExitToStatus(err)
					}

					services := strings.Fields(out)

					if len(services) == 0 {
						return fmt.Errorf("Error: No service (%d) found for %s", logs.GetInt("index"), viper.GetString("project-name"))
					} else if len(services) == 1 {
						logs.Set("service", services[0])
					} else {
						return fmt.Errorf("Error: A service (%d) must be specified for %s, choose one of: [%s]", logs.GetInt("index"), viper.GetString("project-name"), strings.Join(services, " "))
					}
				}
			}

			return nil
		},
		RunE: func(_ *cobra.Command, args []string) error {
			var cmd *system.Cmd

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("logs")
			cmd.Flag("follow", logs.GetBool("follow"))
			cmd.Flag("tail", logs.GetString("tail"))
			cmd.Flag("timestamps", logs.GetBool("timestamps"))
			cmd.Arg(fmt.Sprintf("%s_%s_%d", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_"), logs.GetString("service"), logs.GetInt("index")))
			switch len(args) {
			case 0:
				cmd.Std(nil, os.Stdout, os.Stderr)
			case 1:
				pattern, err := grep.Compile(args[0])
				if err != nil {
					return err
				}

				stdout := pattern.WriteCloser(os.Stdout, !logs.GetBool("no-color"), false)
				defer stdout.Close()

				cmd.Std(nil, stdout, os.Stderr)
			}

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)

var (

	// Ps : docker inaccel ps
	Ps = &cobra.Command{
		Use:   "ps [OPTIONS]",
		Short: "List containers",
		Args:  cobra.NoArgs,
		RunE: func(_ *cobra.Command, _ []string) error {
			var cmd *system.Cmd

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("ps")
			cmd.Flag("all", true)
			cmd.Flag("filter", "label=com.docker.compose.oneoff=False")
			cmd.Flag("filter", fmt.Sprintf("label=com.docker.compose.project=%s", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_")))
			if !ps.GetBool("quiet") {
				cmd.Flag("format", `table {{ .ID }}\t{{ .Image }}\t{{ .RunningFor }}\t{{ .Status }}\t{{ if eq ( .Label "com.docker.compose.service" ) "service" }}SERVICE{{ else }}{{ .Label "com.docker.compose.service" }}{{ end }}\t{{ if eq ( .Label "com.docker.compose.container-number" ) "container number" }}INDEX{{ else }}{{ .Label "com.docker.compose.container-number" }}{{ end }}`)
			}
			cmd.Flag("no-trunc", ps.GetBool("no-trunc"))
			cmd.Flag("quiet", ps.GetBool("quiet"))
			cmd.Std(nil, os.Stdout, os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)

var (

	// Run : docker inaccel run
	Run = &cobra.Command{
		Use:   "run [OPTIONS] SERVICE [COMMAND] [ARG...]",
		Short: "Run a one-off command",
		Args:  cobra.MinimumNArgs(1),
		RunE: func(_ *cobra.Command, args []string) error {
			rootless, err := internal.Rootless()
			if err != nil {
				return err
			}

			var cmd *system.Cmd

			if viper.GetBool("pull") {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("pull")
				cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
				cmd.Std(nil, os.Stdout, os.Stderr)

				if err := cmd.Run(viper.GetBool("debug")); err != nil {
					return internal.ExitToStatus(err)
				}
			}

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("run")
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_PATH", internal.Host.Path))
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_SCHEME", internal.Host.Scheme))
			if rootless {
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CACHE_HOME", xdg.CacheHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_DIRS", strings.Join(xdg.ConfigDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_HOME", xdg.ConfigHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_DIRS", strings.Join(xdg.DataDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_HOME", xdg.DataHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_RUNTIME_DIR", xdg.RuntimeDir))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_STATE_HOME", xdg.StateHome))
			}
			cmd.Flag("env", viper.GetStringSlice("env"))
			if len(viper.GetString("env-file")) > 0 {
				cmd.Flag("env-file", viper.GetString("env-file"))
			} else if _, err := os.Stat(".env"); err == nil {
				cmd.Flag("env-file", ".env")
			}
			cmd.Flag("interactive", true)
			cmd.Flag("rm", true)
			cmd.Flag("tty", !run.GetBool("no-tty") && isatty.IsTerminal(os.Stdin.Fd()) && isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd()))
			cmd.Flag("volume", fmt.Sprintf("%s:%s", internal.Host.Path, "/var/run/docker.sock"))
			cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
			if !run.GetBool("no-tty") && isatty.IsTerminal(os.Stdin.Fd()) && isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd()) {
				cmd.Flag("ansi", "always")
			} else {
				cmd.Flag("ansi", "never")
			}
			cmd.Flag("project-name", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_"))
			cmd.Arg("run")
			cmd.Flag("entrypoint", run.GetString("entrypoint"))
			cmd.Flag("e", run.GetStringSlice("env"))
			cmd.Flag("no-deps", run.GetBool("no-deps"))
			cmd.Flag("publish", run.GetStringSlice("publish"))
			cmd.Flag("rm", true)
			cmd.Flag("service-ports", true)
			cmd.Flag("user", run.GetString("user"))
			cmd.Flag("volume", run.GetStringSlice("volume"))
			cmd.Flag("workdir", run.GetString("workdir"))
			cmd.Arg(args...)
			cmd.Std(os.Stdin, os.Stdout, os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)

var (

	// Up : docker inaccel up
	Up = &cobra.Command{
		Use:   "up [OPTIONS] [SERVICE]",
		Short: "Create and start containers",
		Args:  cobra.MaximumNArgs(1),
		RunE: func(_ *cobra.Command, args []string) error {
			rootless, err := internal.Rootless()
			if err != nil {
				return err
			}

			var cmd *system.Cmd

			if viper.GetBool("pull") {
				cmd = system.Command("docker")
				cmd.Flag("host", internal.Host)
				cmd.Flag("log-level", viper.GetString("log-level"))
				cmd.Arg("pull")
				cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
				cmd.Std(nil, os.Stdout, os.Stderr)

				if err := cmd.Run(viper.GetBool("debug")); err != nil {
					return internal.ExitToStatus(err)
				}
			}

			cmd = system.Command("docker")
			cmd.Flag("host", internal.Host)
			cmd.Flag("log-level", viper.GetString("log-level"))
			cmd.Arg("run")
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_PATH", internal.Host.Path))
			cmd.Flag("env", fmt.Sprintf("%s=%s", "DOCKER_HOST_SCHEME", internal.Host.Scheme))
			if rootless {
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CACHE_HOME", xdg.CacheHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_DIRS", strings.Join(xdg.ConfigDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_CONFIG_HOME", xdg.ConfigHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_DIRS", strings.Join(xdg.DataDirs, ":")))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_DATA_HOME", xdg.DataHome))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_RUNTIME_DIR", xdg.RuntimeDir))
				cmd.Flag("env", fmt.Sprintf("%s=%s", "XDG_STATE_HOME", xdg.StateHome))
			}
			cmd.Flag("env", viper.GetStringSlice("env"))
			if len(viper.GetString("env-file")) > 0 {
				cmd.Flag("env-file", viper.GetString("env-file"))
			} else if _, err := os.Stat(".env"); err == nil {
				cmd.Flag("env-file", ".env")
			}
			cmd.Flag("interactive", true)
			cmd.Flag("rm", true)
			cmd.Flag("volume", fmt.Sprintf("%s:%s", internal.Host.Path, "/var/run/docker.sock"))
			cmd.Arg(fmt.Sprintf("%s:%s", viper.GetString("project-name"), viper.GetString("tag")))
			if isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd()) {
				cmd.Flag("ansi", "always")
			} else {
				cmd.Flag("ansi", "never")
			}
			cmd.Flag("profile", viper.GetStringSlice("profile"))
			cmd.Flag("project-name", regexp.MustCompile("[^-0-9_a-z]").ReplaceAllString(strings.ToLower(viper.GetString("project-name")), "_"))
			cmd.Arg("up")
			cmd.Flag("always-recreate-deps", up.GetBool("always-recreate-deps"))
			cmd.Flag("detach", true)
			cmd.Flag("force-recreate", up.GetBool("force-recreate"))
			cmd.Flag("no-deps", up.GetBool("no-deps"))
			cmd.Flag("no-recreate", up.GetBool("no-recreate"))
			if len(args) > 0 {
				cmd.Arg(args[0])
			}
			cmd.Std(nil, os.Stdout, os.Stderr)

			if err := cmd.Run(viper.GetBool("debug")); err != nil {
				return internal.ExitToStatus(err)
			}

			return nil
		},
	}
)