ChatGPT/Claude CLI Setup

private func runStreamingAndCollect(prompt: String, model: String?, reasoningEffort: String?, sessionId: String?) async throws -> (run: ChatCLIRunResult, sessionId: String?) {
    let started = Date()
    var collectedText = ""
    var capturedSessionId = sessionId

    let stream = runner.runStreaming(
        tool: tool,
        prompt: prompt,
        workingDirectory: config.workingDirectory,
        model: model,
        reasoningEffort: reasoningEffort,
        sessionId: sessionId
    )

    for try await event in stream {
        switch event {
        case .sessionStarted(let id):
            if capturedSessionId == nil {
                capturedSessionId = id
            }
        case .textDelta(let chunk):
            collectedText += chunk
        case .complete(let text):
            collectedText = text
        case .error(let message):
            throw NSError(domain: "ChatCLI", code: -4, userInfo: [...])
        }
    }

    return (run, capturedSessionId)
}

let model: String
let effort: String?
switch tool {
case .claude:
    model = "sonnet"
    effort = nil
case .codex:
    model = "gpt-5.2"
    effort = "medium"
}

private func prepareImagesForCLI(_ imagePaths: [String]) throws -> ([String], () -> Void) {
    let tmpDir = config.workingDirectory.appendingPathComponent("tmp_images_\(UUID().uuidString)", isDirectory: true)
    try fm.createDirectory(at: tmpDir, withIntermediateDirectories: true)

    func resize(_ src: URL, into dst: URL) throws {
        guard let image = NSImage(contentsOf: src) else {
            throw NSError(...)
        }
        
        let maxHeight: Double = 720.0
        if pixelsHigh <= Int(maxHeight) {
            // No resize needed
            try fm.copyItem(at: src, to: dst)
            return
        }

        // Resize and encode as JPEG
        let scale = maxHeight / Double(pixelsHigh)
        let targetW = max(2, Int((Double(pixelsWide) * scale).rounded()))
        let targetH = Int(maxHeight)
        
        // ... resize logic ...
    }
    
    return (processed, cleanup)
}

var sessionId: String? = nil

for attempt in 1...3 {
    let runResult = try await runStreamingAndCollect(
        prompt: actualPromptUsed,
        model: model,
        reasoningEffort: effort,
        sessionId: sessionId  // Reuse session for corrections
    )
    sessionId = runResult.sessionId
    
    // Validation and correction logic
    if !coverageValid || !durationValid {
        // Send correction prompt in same session
        actualPromptUsed = buildCardsCorrectionPrompt(validationError: combinedError)
    }
}

private func extractCLIError(stdout: String, stderr: String) -> String? {
    // Check stderr for ERROR: lines (Codex format)
    for line in stderr.components(separatedBy: .newlines) {
        let trimmed = line.trimmingCharacters(in: .whitespaces)
        if trimmed.hasPrefix("ERROR:") {
            return trimmed
        }
    }

    // Check stdout for API Error messages (Claude format)
    for line in stdout.components(separatedBy: .newlines) {
        let trimmed = line.trimmingCharacters(in: .whitespaces)
        if trimmed.hasPrefix("API Error:") ||
           trimmed.hasPrefix("Invalid API key") ||
           trimmed.hasPrefix("You've hit your limit") {
            return cleaned
        }
    }
    
    return nil
}

private func stripOSCEscapes(_ input: String) -> String {
    // Strip OSC (Operating System Command) sequences like ]1337;RemoteHost=user@host
    var result = ""
    var i = input.startIndex
    while i < input.endIndex {
        if input[i] == "]" {
            // Check for OSC signature (semicolon within first 5 chars)
            if hasSemicolon {
                // Skip the OSC sequence
                var j = next
                while j < input.endIndex {
                    let c = input[j]
                    if c.isNumber || c == ";" || c == "=" || ... {
                        j = input.index(after: j)
                    } else {
                        break
                    }
                }
                i = j
                continue
            }
        }
        result.append(input[i])
        i = input.index(after: i)
    }
    return result
}