RuntimeConfiguration: explicit Codable for path; restore Data(contentsOf:).

Address review feedback on the URL → FilePath conversion of
RuntimeConfiguration.path:

1. FilePath's default Codable encoding exposes its internal _storage
   as a keyed container, while URL's default encoding produced a plain
   absoluteString. Without this fix, runtime-configuration.json files
   written by daemons before the migration would fail to decode after
   upgrade. Add explicit CodingKeys + encode(to:) / init(from:) that
   serialize path as a plain string and accept either form (file:// or
   bare path) on decode for backward compatibility. Add a regression
   test for the legacy URL format.

2. Restore Data(contentsOf: URL(fileURLWithPath:)) for reading the
   config file, matching the codebase precedent (Bundle.swift,
   ConfigurationLoader.swift, EntityStore.swift). FileManager.contents
   would have lost typed CocoaError diagnostics on I/O failure.

Author: chrisgeo

Sources/Services/Runtime/RuntimeClient/RuntimeConfiguration.swift

@@ -51,6 +51,50 @@ public struct RuntimeConfiguration: Codable, Sendable {
         self.runtimeData = runtimeData
     }
 
+    private enum CodingKeys: String, CodingKey {
+        case path
+        case initialFilesystem
+        case kernel
+        case containerConfiguration
+        case containerRootFilesystem
+        case options
+        case runtimeData
+    }
+
+    // FilePath's default Codable encoding exposes its internal _storage and
+    // is not interchangeable with URL's plain-string form. To stay
+    // wire-compatible with runtime-configuration.json files written before
+    // the URL → FilePath migration, encode `path` as a plain string and
+    // accept either the file:// URL form or a bare path on decode.
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let pathString = try container.decode(String.self, forKey: .path)
+        if pathString.hasPrefix("file://"),
+            let url = URL(string: pathString), url.isFileURL
+        {
+            self.path = FilePath(url.path(percentEncoded: false))
+        } else {
+            self.path = FilePath(pathString)
+        }
+        self.initialFilesystem = try container.decode(Filesystem.self, forKey: .initialFilesystem)
+        self.kernel = try container.decode(Kernel.self, forKey: .kernel)
+        self.containerConfiguration = try container.decodeIfPresent(ContainerConfiguration.self, forKey: .containerConfiguration)
+        self.containerRootFilesystem = try container.decodeIfPresent(Filesystem.self, forKey: .containerRootFilesystem)
+        self.options = try container.decodeIfPresent(ContainerCreateOptions.self, forKey: .options)
+        self.runtimeData = try container.decodeIfPresent(Data.self, forKey: .runtimeData)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.path.string, forKey: .path)
+        try container.encode(self.initialFilesystem, forKey: .initialFilesystem)
+        try container.encode(self.kernel, forKey: .kernel)
+        try container.encodeIfPresent(self.containerConfiguration, forKey: .containerConfiguration)
+        try container.encodeIfPresent(self.containerRootFilesystem, forKey: .containerRootFilesystem)
+        try container.encodeIfPresent(self.options, forKey: .options)
+        try container.encodeIfPresent(self.runtimeData, forKey: .runtimeData)
+    }
+
     public var runtimeConfigurationPath: FilePath {
         self.path.appending(Self.runtimeConfigurationFilename)
     }
@@ -72,12 +116,7 @@ public struct RuntimeConfiguration: Codable, Sendable {
             )
         }
 
-        guard let data = FileManager.default.contents(atPath: configurationPath.string) else {
-            throw ContainerizationError(
-                .internalError,
-                message: "failed to read runtime configuration file at path: \(configurationPath.string)"
-            )
-        }
+        let data = try Data(contentsOf: URL(fileURLWithPath: configurationPath.string))
         return try JSONDecoder().decode(RuntimeConfiguration.self, from: data)
     }
 }

Tests/ContainerAPIServiceTests/RuntimeConfigurationTests.swift

@@ -136,4 +136,28 @@ struct RuntimeConfigurationTests {
         let decodedData = try JSONDecoder().decode(LinuxRuntimeData.self, from: readRuntimeConfig.runtimeData!)
         #expect(decodedData.variant == "test-variant", "Variant should round-trip through RuntimeConfiguration")
     }
+
+    /// Verify that runtime-configuration.json files written before the
+    /// URL → FilePath migration (where `path` was a URL absoluteString
+    /// like "file:///foo/bar") still decode correctly. Otherwise an upgrade
+    /// would render existing containers unstartable.
+    @Test
+    func testRuntimeConfigurationDecodesLegacyURLPathFormat() throws {
+        let kernel = Kernel(path: URL(fileURLWithPath: "/path/to/kernel"), platform: .linuxArm)
+        let initFs = Filesystem.virtiofs(source: "/path/to/initfs", destination: "/", options: ["ro"])
+
+        let kernelJSON = try String(data: JSONEncoder().encode(kernel), encoding: .utf8) ?? ""
+        let initFsJSON = try String(data: JSONEncoder().encode(initFs), encoding: .utf8) ?? ""
+
+        let legacyJSON = """
+            {"path":"file:///tmp/legacy-bundle","initialFilesystem":\(initFsJSON),"kernel":\(kernelJSON)}
+            """
+        let data = Data(legacyJSON.utf8)
+
+        let decoded = try JSONDecoder().decode(RuntimeConfiguration.self, from: data)
+
+        #expect(decoded.path == FilePath("/tmp/legacy-bundle"))
+        #expect(decoded.kernel.path == kernel.path)
+        #expect(decoded.initialFilesystem.source == initFs.source)
+    }
 }