internal/container/stop.go (1)

19-27: Timeout is shared across all containers in the loop.

The 10-second timeout applies to the entire function, not per container. If containers has multiple entries, the timeout budget is consumed by earlier iterations, leaving progressively less time for subsequent containers. This could lead to inconsistent behavior where the first container stops successfully but later containers timeout.

Consider either applying timeout per-container or scaling the timeout based on len(containers).

♻️ Option: Per-container timeout

 func Stop(ctx context.Context, rt runtime.Runtime, sink output.Sink, containers []config.ContainerConfig) error {
-	ctx, cancel := context.WithTimeout(ctx, stopTimeout)
-	defer cancel()
-
 	for _, c := range containers {
+		stopCtx, cancel := context.WithTimeout(ctx, stopTimeout)
 		name := c.Name()
-		running, err := rt.IsRunning(ctx, name)
+		running, err := rt.IsRunning(stopCtx, name)
 		if err != nil {
+			cancel()
 			return fmt.Errorf("checking %s running: %w", name, err)
 		}
 		if !running {
+			cancel()
 			return fmt.Errorf("LocalStack is not running")
 		}
 		output.EmitSpinnerStart(sink, "Stopping LocalStack...")
-		if err := rt.Stop(ctx, name); err != nil {
+		if err := rt.Stop(stopCtx, name); err != nil {
 			output.EmitSpinnerStop(sink)
+			cancel()
 			return fmt.Errorf("failed to stop LocalStack: %w", name, err)
 		}
 		output.EmitSpinnerStop(sink)
 		output.EmitSuccess(sink, "LocalStack stopped")
+		cancel()
 	}
 
 	return nil
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/container/stop.go` around lines 19 - 27, The timeout is currently
shared across the entire loop so earlier iterations can consume the 10s budget;
change to apply a per-container timeout by creating a new context with timeout
inside the loop (and defer/call the cancel) before calling rt.IsRunning, or
alternatively compute a scaled timeout like 10s * len(containers) and use that
when creating the ctx; update the loop in stop.go where containers is iterated
and rt.IsRunning(ctx, name) is invoked so each IsRunning call has its own
timeout-bound context (ensure you call the cancel to avoid leaks).

internal/container/stop.go (1)

13-13: Make stop timeout injectable from the command boundary

Line 13 hardcodes 10s in domain logic. Consider passing timeout into Stop(...) so cmd-layer configuration can control it per environment.

As per coding guidelines, "Do not call config.Get() from domain/business-logic packages; extract values at the command boundary (cmd/) and pass as explicit function arguments".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/container/stop.go` at line 13, The hardcoded stopTimeout constant
(stopTimeout = 10 * time.Second) embeds a config value in domain logic; change
the Stop function signature (e.g., Stop(ctx context.Context, timeout
time.Duration) or Stop(ctx, timeout time.Duration) on the relevant type) to
accept a timeout parameter instead of using stopTimeout, remove the
package-level const, update internal uses inside Stop to use the passed timeout
for cancellation/Timer logic, and update all callers to pass the desired timeout
from the command layer (cmd/) where configuration is read.