Command-Line Tools in Swift

// swift-tools-version: 6.0
import PackageDescription

let package = Package(
    name: "shelf",
    platforms: [.macOS(.v13)],
    dependencies: [
        .package(url: "https://github.com/apple/swift-argument-parser", from: "1.8.2"),
        .package(url: "https://github.com/apple/swift-system", from: "1.8.1"),
        .package(url: "https://github.com/swiftlang/swift-subprocess", from: "1.0.2"),
    ],
    targets: [
        .executableTarget(
            name: "shelf",
            dependencies: [
                .product(name: "ArgumentParser", package: "swift-argument-parser"),
                .product(name: "SystemPackage", package: "swift-system"),
                .product(name: "Subprocess", package: "swift-subprocess"),
            ]
        ),
    ]
)

import ArgumentParser
import Foundation

@main
struct Shelf: AsyncParsableCommand {
    static let configuration = CommandConfiguration(
        commandName: "shelf",
        abstract: "Manage the Bookshelf catalogue.",
        discussion: "Examples:\n  shelf add 978-0-13-468599-1 \"The Swift Programming Language\"\n  shelf list --color never",
        version: "0.1.0",
        subcommands: [Add.self, List.self, Import.self, Size.self, Watch.self, Sync.self],
        defaultSubcommand: List.self
    )
}

/// A value type that can be parsed from the command line.
struct ISBN: ExpressibleByArgument, Codable, Equatable {
    let digits: String

    init?(argument: String) {
        let cleaned = argument.filter { $0.isNumber }
        guard cleaned.count == 13 else { return nil }
        digits = cleaned
    }

    var defaultValueDescription: String { digits }
}

enum ColorMode: String, CaseIterable, ExpressibleByArgument {
    case auto, always, never
}

struct GlobalOptions: ParsableArguments {
    @Flag(name: .long, help: "Emit JSON on standard output.")
    var json = false

    @Option(help: "When to use colour.")
    var color: ColorMode = .auto

    @Option(help: "Catalogue file.", completion: .file(extensions: ["json"]))
    var catalogue: String?
}

struct Add: ParsableCommand {
    static let configuration = CommandConfiguration(abstract: "Add a book to the catalogue.")

    @OptionGroup(title: "Global options") var global: GlobalOptions

    @Argument(help: "The 13-digit ISBN; hyphens are ignored.")
    var isbn: ISBN

    @Argument(help: "The title of the book.")
    var title: String

    @Option(name: .shortAndLong, help: "Year of first publication.")
    var year: Int?

    func validate() throws {
        if let year, !(1450...2100).contains(year) {
            throw ValidationError("--year must be between 1450 and 2100, got \(year).")
        }
        if title.trimmingCharacters(in: .whitespaces).isEmpty {
            throw ValidationError("The title must not be empty.")
        }
    }

    func run() throws {
        if global.json {
            print(#"{"isbn":"\#(isbn.digits)","title":"\#(title)","added":true}"#)
        } else {
            print("Added \(title) (\(isbn.digits))")
        }
    }
}

struct List: ParsableCommand {
    static let configuration = CommandConfiguration(abstract: "List the books on the shelf.")

    @OptionGroup(title: "Global options") var global: GlobalOptions

    func run() throws {
        let env = ProcessInfo.processInfo.environment
        let home = env["SHELF_HOME"] ?? "(unset)"
        FileHandle.standardError.write(Data("shelf: catalogue in \(home)\n".utf8))
        print("0 book(s)")
    }
}

struct Import: ParsableCommand {
    static let configuration = CommandConfiguration(abstract: "Read one title per line from standard input.")

    func run() throws {
        var count = 0
        while let line = readLine(strippingNewline: true) {
            let title = line.trimmingCharacters(in: .whitespaces)
            if title.isEmpty { continue }
            count += 1
            print("\(count): \(title)")
        }
        print("imported \(count) title(s)")
    }
}

import ArgumentParser
import Dispatch
import Foundation

struct Watch: AsyncParsableCommand {
    static let configuration = CommandConfiguration(abstract: "Poll the catalogue until interrupted.")

    @Option(help: "Seconds between polls.")
    var interval: Double = 1.0

    func run() async throws {
        // The default action of SIGINT and SIGTERM must be switched off, or the
        // process dies before the dispatch source can run its handler.
        signal(SIGINT, SIG_IGN)
        signal(SIGTERM, SIG_IGN)

        let stream = AsyncStream<Int32> { continuation in
            // A dispatch source that is released is cancelled: keep the sources alive
            // until the stream ends.
            let sources = [SIGINT, SIGTERM].map { number in
                let source = DispatchSource.makeSignalSource(signal: number, queue: .main)
                source.setEventHandler { continuation.yield(number) }
                source.resume()
                return source
            }
            continuation.onTermination = { _ in sources.forEach { $0.cancel() } }
        }

        let seconds = interval
        let poller = Task { () -> Int in
            var polls = 0
            while !Task.isCancelled {
                polls += 1
                print("poll \(polls)")
                try? await Task.sleep(for: .seconds(seconds))
            }
            return polls
        }

        for await number in stream {
            FileHandle.standardError.write(Data("shelf: received signal \(number), stopping\n".utf8))
            poller.cancel()
            break
        }
        let polls = await poller.value
        print("stopped after \(polls) poll(s)")
        throw ExitCode(128 + 2)   // the shell convention for "terminated by SIGINT"
    }
}

$ shelf watch --interval 0.3 > out.txt 2> err.txt &
$ kill -INT $!; wait $!; echo "exit $?"
exit 130
$ cat out.txt err.txt
poll 1
...
poll 5
stopped after 5 poll(s)
shelf: received signal 2, stopping

import ArgumentParser
import Foundation
#if canImport(Darwin)
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WinSDK)
import WinSDK
#endif

/// Size of the terminal attached to standard output, in character cells.
func terminalSize() -> (columns: Int, rows: Int)? {
    #if os(Windows)
    var info = CONSOLE_SCREEN_BUFFER_INFO()
    let handle = GetStdHandle(STD_OUTPUT_HANDLE)
    guard GetConsoleScreenBufferInfo(handle, &info) else { return nil }
    return (Int(info.srWindow.Right - info.srWindow.Left + 1),
            Int(info.srWindow.Bottom - info.srWindow.Top + 1))
    #else
    var size = winsize()
    guard ioctl(STDOUT_FILENO, UInt(TIOCGWINSZ), &size) == 0, size.ws_col > 0 else { return nil }
    return (Int(size.ws_col), Int(size.ws_row))
    #endif
}

struct Size: ParsableCommand {
    static let configuration = CommandConfiguration(abstract: "Print the size of the terminal.")

    func run() throws {
        if let size = terminalSize() {
            print("\(size.columns)x\(size.rows)")
        } else {
            print("not a terminal")
            throw ExitCode.failure
        }
    }
}

$ swift sdk install https://download.swift.org/swift-6.4.1-release/static-sdk/swift-6.4.1-RELEASE/swift-6.4.1-RELEASE_static-linux-0.1.0.artifactbundle.tar.gz --checksum <checksum-from-the-install-page>
$ swift sdk list
$ swift build -c release --swift-sdk x86_64-swift-linux-musl
$ swift build -c release --swift-sdk aarch64-swift-linux-musl
$ file .build/x86_64-swift-linux-musl/release/shelf

$ swift build -c release --arch arm64 --arch x86_64
warning: The x86_64 architecture is deprecated for your deployment target (macOS 27.0). ...
Build complete! (12,12 s)
$ lipo -info "$(swift build -c release --arch arm64 --arch x86_64 --show-bin-path)/shelf"
Architectures in the fat file: .../shelf are: x86_64 arm64

$ codesign --force --options runtime --timestamp --sign "Developer ID Application: Example Corp (TEAMID1234)" shelf
$ ditto -c -k --keepParent shelf shelf.zip
$ xcrun notarytool submit shelf.zip --keychain-profile "shelf-notary" --wait