fix: docker api parallel exec, git config, wrong dir cardinal editor

cmd/world/cardinal/cardinal.go

@@ -20,7 +20,6 @@ var BaseCmd = &cobra.Command{
 			dependency.Go,
 			dependency.Git,
 			dependency.Docker,
-			dependency.DockerCompose,
 			dependency.DockerDaemon,
 		)
 	},

cmd/world/cardinal/dev.go

@@ -132,20 +132,26 @@
 	// Check and wait until Redis is running and is available in the expected port
 	isRedisHealthy := false
 	for !isRedisHealthy {
-		redisAddress := fmt.Sprintf("localhost:%s", RedisPort)
-		conn, err := net.DialTimeout("tcp", redisAddress, time.Second)
-		if err != nil {
-			logger.Printf("Failed to connect to Redis at %s: %s\n", redisAddress, err)
-			time.Sleep(1 * time.Second)
-			continue
-		}
+		// using select to allow for context cancellation
+		select {
+		case <-ctx.Done():
+			return eris.Wrap(ctx.Err(), "Context canceled")
+		default:
+			redisAddress := fmt.Sprintf("localhost:%s", RedisPort)
+			conn, err := net.DialTimeout("tcp", redisAddress, time.Second)
+			if err != nil {
+				logger.Printf("Failed to connect to Redis at %s: %s\n", redisAddress, err)
+				time.Sleep(1 * time.Second)
+				continue
+			}
 
-		// Cleanup connection
-		if err := conn.Close(); err != nil {
-			continue
-		}
+			// Cleanup connection
+			if err := conn.Close(); err != nil {
+				continue
+			}
 
-		isRedisHealthy = true
+			isRedisHealthy = true
+		}
 	}
 
 	// Move into the cardinal directory
@@ -236,10 +242,14 @@
 	}
 	defer dockerClient.Close()
 
+	// Create context with cancel
+	ctx, cancel := context.WithCancel(ctx)
+
 	// Start Redis container
 	group.Go(func() error {
 		cfg.Detach = true
-		if err := dockerClient.Start(ctx, cfg, service.Redis); err != nil {
+		if err := dockerClient.Start(ctx, service.Redis); err != nil {
+			cancel()
 			return eris.Wrap(err, "Encountered an error with Redis")
 		}
 		return nil
@@ -251,7 +261,8 @@
 	// 2) The parent context is canceled for whatever reason.
 	group.Go(func() error {
 		<-ctx.Done()
-		if err := dockerClient.Stop(cfg, service.Redis); err != nil {
+		// Using context background because cmd context is already done
+		if err := dockerClient.Stop(context.Background(), service.Redis); err != nil {
 			return err
 		}
 		return nil

cmd/world/cardinal/purge.go

@@ -34,7 +34,7 @@ This command stop all Docker services and remove all Docker volumes.`,
 		}
 		defer dockerClient.Close()
 
-		err = dockerClient.Purge(cfg, service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
+		err = dockerClient.Purge(cmd.Context(), service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
 		if err != nil {
 			return err
 		}

cmd/world/cardinal/restart.go

@@ -39,7 +39,7 @@ This will restart the following Docker services:
 		}
 		defer dockerClient.Close()
 
-		err = dockerClient.Restart(cmd.Context(), cfg, service.Cardinal, service.Nakama)
+		err = dockerClient.Restart(cmd.Context(), service.Cardinal, service.Nakama)
 		if err != nil {
 			return err
 		}

cmd/world/cardinal/start.go

@@ -120,7 +120,7 @@ This will start the following Docker services and its dependencies:
 
 		// Start the World Engine stack
 		group.Go(func() error {
-			if err := dockerClient.Start(ctx, cfg, service.NakamaDB,
+			if err := dockerClient.Start(ctx, service.NakamaDB,
 				service.Redis, service.Cardinal, service.Nakama); err != nil {
 				return eris.Wrap(err, "Encountered an error with Docker")
 			}

cmd/world/cardinal/stop.go

@@ -38,7 +38,7 @@ This will stop the following Docker services:
 		}
 		defer dockerClient.Close()
 
-		err = dockerClient.Stop(cfg, service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
+		err = dockerClient.Stop(cmd.Context(), service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
 		if err != nil {
 			return err
 		}

cmd/world/cardinal/util_editor.go

@@ -10,19 +10,19 @@
 	"github.com/rotisserie/eris"
 	"golang.org/x/sync/errgroup"
 
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/editor"
 )
 
 const ceReadTimeout = 5 * time.Second
 
 // startCardinalEditor runs the Cardinal Editor
 func startCardinalEditor(ctx context.Context, rootDir string, gameDir string, port int) error {
-	if err := teacmd.SetupCardinalEditor(rootDir, gameDir); err != nil {
+	if err := editor.SetupCardinalEditor(rootDir, gameDir); err != nil {
 		return err
 	}
 
 	// Create a new HTTP server
-	fs := http.FileServer(http.Dir(filepath.Join(rootDir, teacmd.TargetEditorDir)))
+	fs := http.FileServer(http.Dir(filepath.Join(rootDir, editor.EditorDir)))
 	http.Handle("/", fs)
 	server := &http.Server{
 		Addr:        fmt.Sprintf(":%d", port),

cmd/world/evm/start.go

@@ -50,14 +50,15 @@ var startCmd = &cobra.Command{
 		cfg.Detach = false
 		cfg.Timeout = 0
 
-		err = dockerClient.Start(cmd.Context(), cfg, service.EVM)
+		err = dockerClient.Start(cmd.Context(), service.EVM)
 		if err != nil {
 			return fmt.Errorf("error starting %s docker container: %w", teacmd.DockerServiceEVM, err)
 		}
 
 		// Stop the DA service if it was started in dev mode
 		if cfg.DevDA {
-			err = dockerClient.Stop(cfg, service.CelestiaDevNet)
+			// using context background because cmd.Context() is already done
+			err = dockerClient.Stop(context.Background(), service.CelestiaDevNet)
 			if err != nil {
 				return eris.Wrap(err, "Failed to stop DA service")
 			}
@@ -80,7 +81,7 @@ func validateDevDALayer(ctx context.Context, cfg *config.Config, dockerClient *d
 	cfg.Detach = true
 	cfg.Timeout = -1
 	logger.Println("starting DA docker service for dev mode...")
-	if err := dockerClient.Start(ctx, cfg, service.CelestiaDevNet); err != nil {
+	if err := dockerClient.Start(ctx, service.CelestiaDevNet); err != nil {
 		return fmt.Errorf("error starting %s docker container: %w", daService, err)
 	}
 	logger.Println("started DA service...")

cmd/world/evm/stop.go

@@ -27,7 +27,7 @@
 		}
 		defer dockerClient.Close()
 
-		err = dockerClient.Stop(cfg, service.EVM, service.CelestiaDevNet)
+		err = dockerClient.Stop(cmd.Context(), service.EVM, service.CelestiaDevNet)
 		if err != nil {
 			return err
 		}

cmd/world/root/create.go

@@ -8,6 +8,7 @@ import (
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
 
+	"pkg.world.dev/world-cli/common/editor"
 	"pkg.world.dev/world-cli/common/teacmd"
 	"pkg.world.dev/world-cli/tea/component/steps"
 	"pkg.world.dev/world-cli/tea/style"
@@ -123,7 +124,7 @@ func (m WorldCreateModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			)
 		}
 		if msg.Index == 2 { //nolint:gomnd
-			err := teacmd.SetupCardinalEditor(".", "cardinal")
+			err := editor.SetupCardinalEditor(".", "cardinal")
 			teaCmd := func() tea.Msg {
 				return teacmd.GitCloneFinishMsg{Err: err}
 			}

common/docker/client.go

@@ -15,6 +15,36 @@
 	"pkg.world.dev/world-cli/common/logger"
 )
 
+const (
+	START processType = iota
+	STOP
+	REMOVE
+	CREATE
+)
+
+var (
+	processName = map[processType]string{
+		START:  "start",
+		STOP:   "stop",
+		REMOVE: "remove",
+		CREATE: "create",
+	}
+
+	processInitName = map[processType]string{
+		START:  "starting",
+		STOP:   "stopping",
+		REMOVE: "removing",
+		CREATE: "creating",
+	}
+
+	processFinishName = map[processType]string{
+		START:  "started",
+		STOP:   "stopped",
+		REMOVE: "removed",
+		CREATE: "created",
+	}
+)
+
 type Client struct {
 	client *client.Client
 	cfg    *config.Config
@@ -39,32 +69,33 @@
 	return c.client.Close()
 }
 
-func (c *Client) Start(ctx context.Context, cfg *config.Config,
+func (c *Client) Start(ctx context.Context,
 	serviceBuilders ...service.Builder) error {
 	defer func() {
-		if !cfg.Detach {
-			err := c.Stop(cfg, serviceBuilders...)
+		if !c.cfg.Detach {
+			err := c.Stop(context.Background(), serviceBuilders...)
 			if err != nil {
 				logger.Error("Failed to stop containers", err)
 			}
 		}
 	}()
 
-	namespace := cfg.DockerEnv["CARDINAL_NAMESPACE"]
+	namespace := c.cfg.DockerEnv["CARDINAL_NAMESPACE"]
 	err := c.createNetworkIfNotExists(ctx, namespace)
 	if err != nil {
 		return eris.Wrap(err, "Failed to create network")
 	}
 
-	err = c.createVolumeIfNotExists(ctx, namespace)
+	err = c.processVolume(ctx, CREATE, namespace)
 	if err != nil {
 		return eris.Wrap(err, "Failed to create volume")
 	}
 
 	// get all services
 	dockerServices := make([]service.Service, 0)
 	for _, sb := range serviceBuilders {
-		dockerServices = append(dockerServices, sb(cfg))
+		ds := sb(c.cfg)
+		dockerServices = append(dockerServices, ds)
 	}
 
 	// Pull all images before starting containers
@@ -73,67 +104,76 @@
 		return eris.Wrap(err, "Failed to pull images")
 	}
 
-	// Start all containers
-	for _, dockerService := range dockerServices {
-		// build image if needed
-		if cfg.Build && dockerService.Dockerfile != "" {
-			if err := c.buildImage(ctx, dockerService.Dockerfile, dockerService.BuildTarget, dockerService.Image); err != nil {
-				return eris.Wrap(err, "Failed to build image")
-			}
+	// Build all images before starting containers
+	if c.cfg.Build {
+		err = c.buildImages(ctx, dockerServices...)
+		if err != nil {
+			return eris.Wrap(err, "Failed to build images")
 		}
+	}
 
-		// create container & start
-		if err := c.startContainer(ctx, dockerService); err != nil {
-			return eris.Wrap(err, "Failed to create container")
-		}
+	// Start all containers
+	err = c.processMultipleContainers(ctx, START, dockerServices...)
+	if err != nil {
+		return eris.Wrap(err, "Failed to start containers")
 	}
 
 	// log containers if not detached
-	if !cfg.Detach {
+	if !c.cfg.Detach {
 		c.logMultipleContainers(ctx, dockerServices...)
 	}
 
 	return nil
 }
 
-func (c *Client) Stop(cfg *config.Config, serviceBuilders ...service.Builder) error {
-	ctx := context.Background()
+func (c *Client) Stop(ctx context.Context, serviceBuilders ...service.Builder) error {
+	// get all services
+	dockerServices := make([]service.Service, 0)
 	for _, sb := range serviceBuilders {
-		dockerService := sb(cfg)
-		if err := c.stopContainer(ctx, dockerService.Name); err != nil {
-			return eris.Wrap(err, "Failed to stop container")
-		}
+		ds := sb(c.cfg)
+		dockerServices = append(dockerServices, ds)
+	}
+
+	// Stop all containers
+	err := c.processMultipleContainers(ctx, STOP, dockerServices...)
+	if err != nil {
+		return eris.Wrap(err, "Failed to stop containers")
 	}
 
 	return nil
 }
 
-func (c *Client) Purge(cfg *config.Config, serviceBuilders ...service.Builder) error {
-	ctx := context.Background()
+func (c *Client) Purge(ctx context.Context, serviceBuilders ...service.Builder) error {
+	// get all services
+	dockerServices := make([]service.Service, 0)
 	for _, sb := range serviceBuilders {
-		dockerService := sb(cfg)
-		if err := c.removeContainer(ctx, dockerService.Name); err != nil {
-			return eris.Wrap(err, "Failed to remove container")
-		}
+		ds := sb(c.cfg)
+		dockerServices = append(dockerServices, ds)
+	}
+
+	// remove all containers
+	err := c.processMultipleContainers(ctx, REMOVE, dockerServices...)
+	if err != nil {
+		return eris.Wrap(err, "Failed to remove containers")
 	}
 
-	err := c.removeVolume(ctx, cfg.DockerEnv["CARDINAL_NAMESPACE"])
+	err = c.processVolume(ctx, REMOVE, c.cfg.DockerEnv["CARDINAL_NAMESPACE"])
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (c *Client) Restart(ctx context.Context, cfg *config.Config,
+func (c *Client) Restart(ctx context.Context,
 	serviceBuilders ...service.Builder) error {
 	// stop containers
-	err := c.Stop(cfg, serviceBuilders...)
+	err := c.Stop(ctx, serviceBuilders...)
 	if err != nil {
 		return err
 	}
 
-	return c.Start(ctx, cfg, serviceBuilders...)
+	return c.Start(ctx, serviceBuilders...)
 }
 
 func (c *Client) Exec(ctx context.Context, containerID string, cmd []string) (string, error) {