Merge pull request #85 from zero-ide/feature/timeout-retry-policy

feat(execution): add timeout and retry policy for runtime installs

Author: ori0o0p

Sources/Zero/Services/ExecutionService.swift

@@ -15,6 +15,9 @@ class ExecutionService: ObservableObject {
     @Published var status: ExecutionStatus = .idle
     @Published var output: String = ""
     private var cancellationRequested = false
+    private let installTimeoutSeconds: TimeInterval = 20
+    private let installMaxAttempts = 3
+    private let installRetryDelayNanoseconds: UInt64 = 300_000_000
 
     init(
         dockerService: DockerServiceProtocol,
@@ -85,19 +88,70 @@ class ExecutionService: ObservableObject {
     private func setupEnvironment(for command: String, container: String) async throws {
         if command.contains("npm") {
             await MainActor.run { self.output += "\n📦 Installing Node.js..." }
-            _ = try dockerService.executeShell(container: container, script: "apk add --no-cache nodejs npm")
+            try await installPackage(
+                container: container,
+                script: "apk add --no-cache nodejs npm",
+                runtimeName: "Node.js"
+            )
         } else if command.contains("python") {
             await MainActor.run { self.output += "\n📦 Installing Python..." }
-            _ = try dockerService.executeShell(container: container, script: "apk add --no-cache python3")
+            try await installPackage(
+                container: container,
+                script: "apk add --no-cache python3",
+                runtimeName: "Python"
+            )
         } else if command.contains("javac") || command.contains("mvn") || command.contains("gradle") {
             await MainActor.run { self.output += "\n📦 Setting up Java environment..." }
             // Note: JDK should be pre-installed in the container image
             // This is handled by using the configured JDK image
         } else if command.contains("go") {
             await MainActor.run { self.output += "\n📦 Installing Go..." }
-            _ = try dockerService.executeShell(container: container, script: "apk add --no-cache go")
+            try await installPackage(
+                container: container,
+                script: "apk add --no-cache go",
+                runtimeName: "Go"
+            )
         }
     }
+
+    private func installPackage(container: String, script: String, runtimeName: String) async throws {
+        var lastError: Error?
+
+        for attempt in 1...installMaxAttempts {
+            do {
+                let timeoutScript = "timeout \(Int(installTimeoutSeconds)) sh -lc \"\(escapeForDoubleQuotedShell(script))\""
+                _ = try dockerService.executeShell(container: container, script: timeoutScript)
+                return
+            } catch {
+                lastError = error
+
+                if attempt == installMaxAttempts {
+                    let debugDetails = "runtime=\(runtimeName) attempts=\(installMaxAttempts) timeoutSeconds=\(installTimeoutSeconds) lastError=\(error.localizedDescription)"
+                    throw ZeroError.runtimeCommandFailed(
+                        userMessage: "Failed to install \(runtimeName) after \(installMaxAttempts) attempts.",
+                        debugDetails: debugDetails
+                    )
+                }
+
+                await MainActor.run {
+                    self.output += "\n⚠️ Retrying \(runtimeName) installation (attempt \(attempt + 1)/\(installMaxAttempts))..."
+                }
+                try? await Task.sleep(nanoseconds: installRetryDelayNanoseconds)
+            }
+        }
+
+        let fallbackMessage = "Failed to install \(runtimeName) after \(installMaxAttempts) attempts."
+        throw ZeroError.runtimeCommandFailed(
+            userMessage: fallbackMessage,
+            debugDetails: "runtime=\(runtimeName) lastError=\(lastError?.localizedDescription ?? "unknown")"
+        )
+    }
+
+    private func escapeForDoubleQuotedShell(_ script: String) -> String {
+        script
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+    }
 
     func createJavaContainer(name: String) async throws -> String {
         let config = try buildConfigService.load()

Tests/ZeroTests/ExecutionServiceTests.swift

@@ -231,6 +231,57 @@ final class ExecutionServiceTests: XCTestCase {
         XCTAssertTrue(service.output.contains("❌ Error: Docker shell command failed."))
     }
 
+    func testRunRetriesPackageInstallAfterTransientFailure() async {
+        // Given
+        mockDocker.scriptedShellResults = [
+            .failure(ZeroError.runtimeCommandFailed(userMessage: "Docker shell command timed out.", debugDetails: "attempt 1 timeout")),
+            .success(""),
+            .success("run ok")
+        ]
+
+        // When
+        await service.run(container: "test-container", command: "npm start")
+
+        // Then
+        XCTAssertEqual(service.status, .success)
+        XCTAssertTrue(service.output.contains("Retrying Node.js installation (attempt 2/3)"))
+
+        let installCommands = mockDocker.executedShellScripts.filter { $0.contains("apk add --no-cache nodejs npm") }
+        XCTAssertEqual(installCommands.count, 2)
+    }
+
+    func testRunFailsWhenPackageInstallRetriesExhausted() async {
+        // Given
+        mockDocker.scriptedShellResults = [
+            .failure(ZeroError.runtimeCommandFailed(userMessage: "Docker shell command timed out.", debugDetails: "attempt 1 timeout")),
+            .failure(ZeroError.runtimeCommandFailed(userMessage: "Docker shell command timed out.", debugDetails: "attempt 2 timeout")),
+            .failure(ZeroError.runtimeCommandFailed(userMessage: "Docker shell command timed out.", debugDetails: "attempt 3 timeout"))
+        ]
+
+        // When
+        await service.run(container: "test-container", command: "npm start")
+
+        // Then
+        XCTAssertEqual(service.status, .failed("Failed to install Node.js after 3 attempts."))
+        XCTAssertTrue(service.output.contains("❌ Error: Failed to install Node.js after 3 attempts."))
+    }
+
+    func testRunWrapsPackageInstallWithTimeoutPolicy() async {
+        // Given
+        mockDocker.scriptedShellResults = [.success(""), .success("run ok")]
+
+        // When
+        await service.run(container: "test-container", command: "npm start")
+
+        // Then
+        guard let installScript = mockDocker.executedShellScripts.first(where: { $0.contains("apk add --no-cache nodejs npm") }) else {
+            XCTFail("Expected Node.js install command to run")
+            return
+        }
+
+        XCTAssertTrue(installScript.contains("timeout 20 sh -lc"))
+    }
+
     func testSaveAndLoadRunProfileCommand() throws {
         // Given
         let repositoryURL = URL(string: "https://github.com/zero-ide/Zero.git")!
@@ -319,6 +370,8 @@ class MockExecutionDockerService: DockerServiceProtocol {
     var interChunkDelayNanoseconds: UInt64 = 0
     var dockerCommandAvailable = true
     var executionError: Error?
+    var scriptedShellResults: [Result<String, Error>] = []
+    var executedShellScripts: [String] = []
 
     func checkInstallation() throws -> Bool { return true }
 
@@ -334,6 +387,18 @@ class MockExecutionDockerService: DockerServiceProtocol {
     func runContainer(image: String, name: String) throws -> String { return "" }
     func executeCommand(container: String, command: String) throws -> String { return "" }
     func executeShell(container: String, script: String) throws -> String {
+        executedShellScripts.append(script)
+
+        if !scriptedShellResults.isEmpty {
+            let nextResult = scriptedShellResults.removeFirst()
+            switch nextResult {
+            case .success(let output):
+                return output
+            case .failure(let error):
+                throw error
+            }
+        }
+
         if let executionError {
             throw executionError
         }