fix: improve container running checks with custom container_name support

- Rename getIPForRunningService to getIPForContainer to accept containerName directly
- Rename waitUntilServiceIsRunning to waitUntilContainerIsRunning
- Add status tracking for better error messages on timeout
- Check if container already exists before starting
- Support custom container_name when checking container status
- Update stopOldStuff in ComposeUp to respect custom container_name (consistency with ComposeDown)

This fixes timeout issues where containers started correctly but checks
failed because they were looking for the wrong container name.

Co-authored-by: TomasLudvik <5638367+TomasLudvik@users.noreply.github.com>

Author: ttys3

Sources/Container-Compose/Commands/ComposeUp.swift

@@ -143,7 +143,7 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
         }
 
         // Stop Services
-        try await stopOldStuff(services.map({ $0.serviceName }), remove: true)
+        try await stopOldStuff(services, remove: true)
 
         // Process top-level networks
         // This creates named networks defined in the docker-compose.yml
@@ -186,11 +186,7 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
         fatalError("unreachable")
     }
 
-    private func getIPForRunningService(_ serviceName: String) async throws -> String? {
-        guard let projectName else { return nil }
-
-        let containerName = "\(projectName)-\(serviceName)"
-
+    private func getIPForContainer(_ containerName: String) async throws -> String? {
         let container = try await ClientContainer.get(id: containerName)
         let ip = container.networks.first?.ipv4Address.address.description
 
@@ -202,36 +198,47 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
     ///   - containerName: The exact name of the container (e.g. "Assignment-Manager-API-db").
     ///   - timeout: Max seconds to wait before failing.
     ///   - interval: How often to poll (in seconds).
-    /// - Returns: `true` if the container reached "running" state within the timeout.
-    private func waitUntilServiceIsRunning(_ serviceName: String, timeout: TimeInterval = 30, interval: TimeInterval = 0.5) async throws {
-        guard let projectName else { return }
-        let containerName = "\(projectName)-\(serviceName)"
-
+    private func waitUntilContainerIsRunning(_ containerName: String, timeout: TimeInterval = 30, interval: TimeInterval = 0.5) async throws {
         let deadline = Date().addingTimeInterval(timeout)
+        var lastStatusDescription: String?
 
         while Date() < deadline {
-            let container = try? await ClientContainer.get(id: containerName)
-            if container?.status == .running {
-                return
+            do {
+                let container = try await ClientContainer.get(id: containerName)
+                lastStatusDescription = "\(container.status)"
+                if container.status == .running {
+                    print("Container '\(containerName)' is now running.")
+                    return
+                }
+            } catch {
+                // Container doesn't exist yet, keep polling
             }
 
             try await Task.sleep(nanoseconds: UInt64(interval * 1_000_000_000))
         }
 
+        let statusMessage = lastStatusDescription.map { "Last status: \($0)" } ?? "Container was never found"
         throw NSError(
             domain: "ContainerWait", code: 1,
             userInfo: [
-                NSLocalizedDescriptionKey: "Timed out waiting for container '\(containerName)' to be running."
+                NSLocalizedDescriptionKey: "Timed out waiting for container '\(containerName)' to be running. \(statusMessage)"
             ])
     }
 
-    private func stopOldStuff(_ services: [String], remove: Bool) async throws {
+    private func stopOldStuff(_ services: [(serviceName: String, service: Service)], remove: Bool) async throws {
         guard let projectName else { return }
-        let containers = services.map { "\(projectName)-\($0)" }
 
-        for container in containers {
-            print("Stopping container: \(container)")
-            guard let container = try? await ClientContainer.get(id: container) else { continue }
+        for (serviceName, service) in services {
+            // Respect explicit container_name, otherwise use default pattern
+            let containerName: String
+            if let explicitContainerName = service.container_name {
+                containerName = explicitContainerName
+            } else {
+                containerName = "\(projectName)-\(serviceName)"
+            }
+
+            print("Stopping container: \(containerName)")
+            guard let container = try? await ClientContainer.get(id: containerName) else { continue }
 
             do {
                 try await container.stop()
@@ -250,8 +257,8 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
 
     // MARK: Compose Top Level Functions
 
-    private mutating func updateEnvironmentWithServiceIP(_ serviceName: String) async throws {
-        let ip = try await getIPForRunningService(serviceName)
+    private mutating func updateEnvironmentWithServiceIP(_ serviceName: String, containerName: String) async throws {
+        let ip = try await getIPForContainer(containerName)
         self.containerIps[serviceName] = ip
         for (key, value) in environmentVariables.map({ ($0, $1) }) where value == serviceName {
             self.environmentVariables[key] = ip ?? value
@@ -554,6 +561,18 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
 
         self.containerConsoleColors[serviceName] = serviceColor
 
+        // Check if container already exists
+        if let existingContainer = try? await ClientContainer.get(id: containerName) {
+            if existingContainer.status == .running {
+                print("Container '\(containerName)' is already running.")
+                try await updateEnvironmentWithServiceIP(serviceName, containerName: containerName)
+                return
+            } else {
+                print("Error: Container '\(containerName)' already exists with status: \(existingContainer.status).")
+                return
+            }
+        }
+
         Task { [self, serviceColor] in
             @Sendable
             func handleOutput(_ output: String) {
@@ -568,8 +587,8 @@ public struct ComposeUp: AsyncParsableCommand, @unchecked Sendable {
         }
 
         do {
-            try await waitUntilServiceIsRunning(serviceName)
-            try await updateEnvironmentWithServiceIP(serviceName)
+            try await waitUntilContainerIsRunning(containerName)
+            try await updateEnvironmentWithServiceIP(serviceName, containerName: containerName)
         } catch {
             print(error)
         }