Consolidate CLI formatting infrastructure (apple#1385)

## Motivation and Context
This PR consolidates duplicated list-output formatting across the CLI
into shared rendering infrastructure.

Currently, each list command has its own copy of the same
json/quiet/table branching. This PR pulls that into shared rendering
infrastructure in `ContainerCommands`:
- `ListDisplayable` protocol for table + quiet output
- `renderJSON`, `renderTable`, `renderList` as pure functions that
return strings
- `emit()` as the single stdout boundary (no-ops on empty strings to
avoid blank-line regressions)
- `JSONOptions` so all JSON encoding goes through one path, including
volume inspect's pretty + ISO 8601 case

JSON encoding remains separate from display formatting: each command
still chooses its own JSON model, while `ListDisplayable` is used only
for table and quiet output. `ImageList` remains the intentional
exception for quiet mode so it can avoid unnecessary async work.

This change also replaces inline `JSONEncoder` usage with `renderJSON`,
removes the old `Codable+JSON.swift` helper, and moves `TableOutput` and
`ListFormat` into `ContainerCommands`. It also adds unit tests for the
shared rendering helpers and expands integration coverage for image,
network, and registry list formatting.

## Testing
- [x] Tested locally
- [x] Added/updated tests
- [ ] Added/updated docs

Author: realrajaryan

Package.swift

@@ -122,6 +122,13 @@ let package = Package(
                 "ContainerBuild"
             ]
         ),
+        .testTarget(
+            name: "ContainerCommandsTests",
+            dependencies: [
+                "ContainerCommands",
+                "ContainerResource",
+            ]
+        ),
         .executableTarget(
             name: "container-apiserver",
             dependencies: [

Sources/ContainerCommands/Application.swift

@@ -245,11 +245,6 @@ extension Application {
         print(altered)
     }
 
-    public enum ListFormat: String, CaseIterable, ExpressibleByArgument {
-        case json
-        case table
-    }
-
     func isTranslated() throws -> Bool {
         do {
             return try Sysctl.byName("sysctl.proc_translated") == 1

Sources/ContainerCommands/Builder/BuilderStatus.swift

@@ -45,60 +45,53 @@ extension Application {
             do {
                 let client = ContainerClient()
                 let container = try await client.get(id: "buildkit")
-                try printContainers(containers: [container], format: format)
+
+                if format == .json {
+                    try Output.emit(Output.renderJSON([PrintableContainer(container)]))
+                    return
+                }
+
+                if quiet && container.status != .running {
+                    return
+                }
+
+                Output.emit(Output.renderList([PrintableBuilder(container)], quiet: quiet))
             } catch {
-                if error is ContainerizationError {
-                    if (error as? ContainerizationError)?.code == .notFound && !quiet {
+                if let czError = error as? ContainerizationError, czError.code == .notFound {
+                    if !quiet {
                         print("builder is not running")
                         return
                     }
                 }
                 throw error
             }
         }
+    }
+}
 
-        private func createHeader() -> [[String]] {
-            [["ID", "IMAGE", "STATE", "ADDR", "CPUS", "MEMORY"]]
-        }
-
-        private func printContainers(containers: [ContainerSnapshot], format: ListFormat) throws {
-            if format == .json {
-                let printables = containers.map {
-                    PrintableContainer($0)
-                }
-                let data = try JSONEncoder().encode(printables)
-                print(String(decoding: data, as: UTF8.self))
-
-                return
-            }
-
-            if self.quiet {
-                containers
-                    .filter { $0.status == .running }
-                    .forEach { print($0.id) }
-                return
-            }
+private struct PrintableBuilder: ListDisplayable {
+    let snapshot: ContainerSnapshot
 
-            var rows = createHeader()
-            for container in containers {
-                rows.append(container.asRow)
-            }
+    init(_ snapshot: ContainerSnapshot) {
+        self.snapshot = snapshot
+    }
 
-            let formatter = TableOutput(rows: rows)
-            print(formatter.format())
-        }
+    static var tableHeader: [String] {
+        ["ID", "IMAGE", "STATE", "ADDR", "CPUS", "MEMORY"]
     }
-}
 
-extension ContainerSnapshot {
-    fileprivate var asRow: [String] {
+    var tableRow: [String] {
         [
-            self.id,
-            self.configuration.image.reference,
-            self.status.rawValue,
-            self.networks.compactMap { $0.ipv4Address.description }.joined(separator: ","),
-            "\(self.configuration.resources.cpus)",
-            "\(self.configuration.resources.memoryInBytes / (1024 * 1024)) MB",
+            snapshot.id,
+            snapshot.configuration.image.reference,
+            snapshot.status.rawValue,
+            snapshot.networks.map { $0.ipv4Address.description }.joined(separator: ","),
+            "\(snapshot.configuration.resources.cpus)",
+            "\(snapshot.configuration.resources.memoryInBytes / (1024 * 1024)) MB",
         ]
     }
+
+    var quietValue: String {
+        snapshot.id
+    }
 }

Sources/ContainerCommands/Container/ContainerInspect.swift

@@ -36,12 +36,12 @@ extension Application {
 
         public func run() async throws {
             let client = ContainerClient()
-            let objects: [any Codable] = try await client.list().filter {
+            let containers = try await client.list().filter {
                 containerIds.contains($0.id)
             }.map {
                 PrintableContainer($0)
             }
-            print(try objects.jsonArray())
+            try Output.emit(Output.renderJSON(containers))
         }
     }
 }

Sources/ContainerCommands/Container/ContainerList.swift

@@ -46,59 +46,37 @@ extension Application {
             let client = ContainerClient()
             let filters = self.all ? ContainerListFilters.all : ContainerListFilters(status: .running)
             let containers = try await client.list(filters: filters)
-            try printContainers(containers: containers, format: format)
-        }
-
-        private func createHeader() -> [[String]] {
-            [["ID", "IMAGE", "OS", "ARCH", "STATE", "ADDR", "CPUS", "MEMORY", "STARTED"]]
-        }
-
-        private func printContainers(containers: [ContainerSnapshot], format: ListFormat) throws {
-            if format == .json {
-                let printables = containers.map {
-                    PrintableContainer($0)
-                }
-                let data = try JSONEncoder().encode(printables)
-                print(String(decoding: data, as: UTF8.self))
-
-                return
-            }
-
-            if self.quiet {
-                containers.forEach {
-                    print($0.id)
-                }
-                return
-            }
-
-            var rows = createHeader()
-            for container in containers {
-                rows.append(container.asRow)
-            }
-
-            let formatter = TableOutput(rows: rows)
-            print(formatter.format())
+            let items = containers.map { PrintableContainer($0) }
+            try Output.render(json: items, display: items, format: format, quiet: quiet)
         }
     }
 }
 
-extension ContainerSnapshot {
-    fileprivate var asRow: [String] {
+extension PrintableContainer: ListDisplayable {
+    static var tableHeader: [String] {
+        ["ID", "IMAGE", "OS", "ARCH", "STATE", "ADDR", "CPUS", "MEMORY", "STARTED"]
+    }
+
+    var tableRow: [String] {
         [
-            self.id,
+            self.configuration.id,
             self.configuration.image.reference,
-            self.platform.os,
-            self.platform.architecture,
+            self.configuration.platform.os,
+            self.configuration.platform.architecture,
             self.status.rawValue,
-            self.networks.compactMap { $0.ipv4Address.description }.joined(separator: ","),
+            self.networks.map { $0.ipv4Address.description }.joined(separator: ","),
             "\(self.configuration.resources.cpus)",
             "\(self.configuration.resources.memoryInBytes / (1024 * 1024)) MB",
-            self.startedDate.map { ISO8601DateFormatter().string(from: $0) } ?? "",
+            self.startedDate?.ISO8601Format() ?? "",
         ]
     }
+
+    var quietValue: String {
+        self.configuration.id
+    }
 }
 
-struct PrintableContainer: Codable {
+struct PrintableContainer: Codable, Sendable {
     let status: RuntimeStatus
     let configuration: ContainerConfiguration
     let networks: [Attachment]

Sources/ContainerCommands/Container/ContainerStats.swift

@@ -104,8 +104,7 @@ extension Application {
 
             if format == .json {
                 let jsonStats = statsData.map { $0.stats2 }
-                let data = try JSONEncoder().encode(jsonStats)
-                print(String(decoding: data, as: UTF8.self))
+                try Output.emit(Output.renderJSON(jsonStats))
                 return
             }
 

Sources/ContainerCommands/Image/ImageInspect.swift

@@ -17,6 +17,7 @@
 import ArgumentParser
 import ContainerAPIClient
 import ContainerLog
+import ContainerResource
 import ContainerizationError
 import Foundation
 import Logging
@@ -42,7 +43,7 @@ extension Application {
         }
 
         public func run() async throws {
-            var printable = [any Codable]()
+            var printable: [ImageDetail] = []
             var succeededImages: [String] = []
             var allErrors: [(String, Error)] = []
 
@@ -59,7 +60,7 @@ extension Application {
             }
 
             if !printable.isEmpty {
-                print(try printable.jsonArray())
+                try Output.emit(Output.renderJSON(printable))
             }
 
             if !allErrors.isEmpty {