Subprocess 1.0 アップデート

// 変更前
public func run<...>(
    ...,
    isolation: isolated (any Actor)? = #isolation,
    body: (_ execution: Execution) async throws -> Result
) async throws -> ExecutionOutcome<Result> where Error.OutputType == Void

// 変更後
public func run<...>(
    ...,
    body: (_ execution: Execution) async throws -> Result
) async throws -> ExecutionOutcome<Result> where Error.OutputType == Void

// 変更前
let result = try await run(...) { execution in
    for try await item in execution.standardOutput { ... }
}

// 変更後
let result = try await run(...) { execution, standardInput, standardOutput, standardError in
    for await item in standardOutput { ... }
}

public func run<Result, Input: InputProtocol, Error: ErrorOutputProtocol>(
    _ executable: Executable,
    arguments: Arguments = [],
    environment: Environment = .inherit,
    workingDirectory: FilePath? = nil,
    platformOptions: PlatformOptions = PlatformOptions(),
    input: Input = .none,
    error: Error = .discarded,
    preferredBufferSize: Int? = nil,
    body: (
        _ execution: Execution,
        _ outputSequence: AsyncBufferSequence
    ) async throws -> Result
) async throws -> ExecutionResult<Result> where Error.OutputType == Void

public struct AsyncBufferSequence: AsyncSequence, Sendable {
    public typealias Failure = any Swift.Error
    public typealias Element = Buffer

    public struct Iterator: AsyncIteratorProtocol {
        public typealias Element = Buffer
        public mutating func next() async throws -> Buffer?
    }

    public func makeAsyncIterator() -> Iterator
}

async let monitorResult = try await Subprocess.run(
    .path("/usr/bin/tail"),
    arguments: ["-f", "/path/to/nginx.log"]
) { execution, standardOutput in
    for try await line in standardOutput.strings() {
        if line.contains("500") {
            // 500 エラーを処理
        }
    }
}

extension Environment {
    public struct Key: Codable, Hashable, ExpressibleByStringLiteral, Sendable {
        public var rawValue: String
    }
}

extension Environment.Key: CodingKeyRepresentable, Comparable, RawRepresentable, CustomStringConvertible {}

public protocol ErrorOutputProtocol: OutputProtocol {}

public struct CombinedErrorOutput: ErrorOutputProtocol {
    public typealias OutputType = Void
}

extension ErrorOutputProtocol where Self == CombinedErrorOutput {
    public static var combinedWithOutput: Self
}

let result = try await run(
    .path("/bin/sh"),
    arguments: ["-c", "echo Hello Stdout; echo Hello Stderr 1>&2"],
    output: .string(limit: 1024),
    error: .combinedWithOutput
)
// result.standardOutput は "Hello Stdout;\nHello Stderr"

// Linux / Android / FreeBSD
public struct ProcessIdentifier: Sendable, Hashable {
    public let value: pid_t

    #if os(Linux) || os(Android) || os(FreeBSD)
    public let processDescriptor: CInt
    #endif
}

// Windows
public struct ProcessIdentifier: Sendable, Hashable {
    public let value: DWORD
    public nonisolated(unsafe) let processDescriptor: HANDLE
    public nonisolated(unsafe) let threadHandle: HANDLE
}

extension OutputProtocol where Self == FileDescriptorOutput {
    public static var currentStandardOutput: Self
    public static var currentStandardError: Self
}

public enum TerminationStatus: Sendable, Hashable {
    #if os(Windows)
    public typealias Code = DWORD
    #else
    public typealias Code = CInt
    #endif

    case exited(Code)

    #if !os(Windows)
    case signaled(Code)
    #endif

    public var isSuccess: Bool
}

public struct SubprocessError: Swift.Error, Sendable, Hashable {
    #if os(Windows)
    public typealias UnderlyingError = WindowsError
    #else
    public typealias UnderlyingError = Errno
    #endif

    public let code: SubprocessError.Code
    public let underlyingError: UnderlyingError?
}

extension SubprocessError {
    public struct Code: Hashable, Sendable {}
}

extension SubprocessError.Code {
    public static var spawnFailed: Self
    public static var executableNotFound: Self
    public static var failedToChangeWorkingDirectory: Self
    public static var failedToMonitorProcess: Self
    public static var failedToReadFromSubprocess: Self
    public static var failedToWriteToSubprocess: Self
    public static var outputLimitExceeded: Self
    public static var asyncIOFailed: Self
    public static var processControlFailed: Self
}

do {
    let result = try await run(...) { execution, standardInput, standardOutput, standardError in
        // 開発者は任意のエラーを throw できる
        throw MyError()
    }
} catch let subprocessError as SubprocessError {
    switch subprocessError.code {
    case .spawnFailed:
        // spawn 失敗
    default:
        break
    }
} catch let myError as MyError {
    // body から投げた独自エラー
}