feat: Implement Model Management System

- Added ModelManager for handling model loading, saving, and management.
- Introduced ModelMetaLoader for loading model metadata based on different formats.
- Created ModelsMeta struct to manage model information and metadata storage.
- Updated URL extension methods to use a new appending method for path components.
- Enhanced VCamSceneDataStore and other components to utilize the new URL methods.
- Added ModelListView for displaying and managing models in the UI.
- Implemented localization for model management actions and messages.
- Refactored migration logic to support new model management features.
- Updated various UI components to integrate model loading and management functionalities.

Author: tattn

app/xcode/Sources/VCamData/ModelManager.swift

@@ -0,0 +1,206 @@
+import AppKit
+import Observation
+import VCamEntity
+
+@Observable
+public final class ModelManager {
+    public static let shared = ModelManager()
+
+    public private(set) var models: [ModelsMeta.ModelInfo] = []
+    public private(set) var lastLoadedModelId: UUID?
+
+    private let fileManager = FileManager.default
+
+    private init() {
+        loadMeta()
+        validateModels()
+    }
+
+    #if DEBUG
+    public init(models: [ModelsMeta.ModelInfo], lastLoadedModelId: UUID? = nil) {
+        self.models = models
+        self.lastLoadedModelId = lastLoadedModelId
+    }
+    #endif
+
+    public var lastLoadedModel: ModelsMeta.ModelInfo? {
+        guard let id = lastLoadedModelId else { return nil }
+        return models.first { $0.id == id }
+    }
+
+    public func setLastLoadedModel(_ model: ModelsMeta.ModelInfo) {
+        lastLoadedModelId = model.id
+        saveMeta()
+    }
+
+    @MainActor
+    public func saveModel(from source: URL, name: String? = nil) async throws -> ModelsMeta.ModelInfo {
+#if FEATURE_3
+        let baseName = name ?? source.deletingPathExtension().lastPathComponent
+#else
+        let baseName = name ?? source.lastPathComponent
+#endif
+        let directoryName = generateUniqueDirectoryName(baseName: baseName)
+        let modelDirectory = ModelsMeta.modelDirectory(ofName: directoryName)
+        try fileManager.createDirectoryIfNeeded(at: modelDirectory)
+
+        let destinationURL = modelDirectory.appending(path: ModelsMeta.modelFileName)
+        if fileManager.fileExists(atPath: destinationURL.path) {
+            try fileManager.removeItem(at: destinationURL)
+        }
+        try fileManager.copyItem(at: source, to: destinationURL)
+
+        let modelInfo = ModelsMeta.ModelInfo(name: directoryName, type: ModelsMeta.modelType)
+        await saveThumbnail(for: modelInfo)
+        addModel(modelInfo)
+        return modelInfo
+    }
+
+    @MainActor
+    private func saveThumbnail(for model: ModelsMeta.ModelInfo) async {
+        let metadata = await Task.detached(priority: .utility) {
+            try? ModelMetaLoader.load(from: model.modelURL)
+        }.value
+
+        if let image = metadata?.image {
+            saveThumbnail(image, for: model)
+        }
+    }
+
+    public func deleteModel(_ model: ModelsMeta.ModelInfo) throws {
+        let modelDirectory = model.rootURL
+        if fileManager.fileExists(atPath: modelDirectory.path) {
+            try fileManager.removeItem(at: modelDirectory)
+        }
+        removeModel(model)
+    }
+
+    @MainActor
+    public func duplicateModel(_ model: ModelsMeta.ModelInfo) async throws -> ModelsMeta.ModelInfo {
+        guard model.status == .valid else {
+            throw ModelManagerError.modelURLNotFound
+        }
+        return try await saveModel(from: model.modelURL, name: "\(model.name)_copy")
+    }
+
+    public func moveModel(fromOffsets source: IndexSet, toOffset destination: Int) {
+        models.move(fromOffsets: source, toOffset: destination)
+        saveMeta()
+    }
+
+    public func renameModel(_ model: ModelsMeta.ModelInfo, to newName: String) {
+        let trimmedName = newName.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmedName.isEmpty, trimmedName != model.localizedName else { return }
+
+        if let index = models.firstIndex(where: { $0.id == model.id }) {
+            models[index].displayName = trimmedName
+        }
+        saveMeta()
+    }
+
+    public func refresh() {
+        validateModels()
+    }
+
+    private func generateUniqueDirectoryName(baseName: String) -> String {
+        var name = baseName
+        var counter = 1
+        while models.contains(where: { $0.name == name }) || fileManager.fileExists(atPath: ModelsMeta.modelDirectory(ofName: name).path) {
+            counter += 1
+            name = "\(baseName)_\(counter)"
+        }
+        return name
+    }
+
+    private func validateModels() {
+        for i in models.indices {
+            let url = models[i].modelURL
+            models[i].status = fileManager.fileExists(atPath: url.path) ? .valid : .missing
+        }
+        scanForNewModels()
+        saveMeta()
+    }
+
+    private func scanForNewModels() {
+        guard fileManager.fileExists(atPath: ModelsMeta.modelsDirectory.path) else { return }
+
+        do {
+            let contents = try fileManager.contentsOfDirectory(
+                at: ModelsMeta.modelsDirectory,
+                includingPropertiesForKeys: [.creationDateKey],
+                options: [.skipsHiddenFiles]
+            )
+
+            let existingNames = Set(models.map { $0.name })
+
+            for directory in contents {
+                let name = directory.lastPathComponent
+                guard name != "meta.json", !existingNames.contains(name) else { continue }
+
+                let modelFile = directory.appending(path: ModelsMeta.modelFileName)
+                guard fileManager.fileExists(atPath: modelFile.path) else { continue }
+
+                let attributes = try? fileManager.attributesOfItem(atPath: modelFile.path)
+                let createdAt = attributes?[.creationDate] as? Date ?? Date()
+                let modelInfo = ModelsMeta.ModelInfo(name: name, type: ModelsMeta.modelType, createdAt: createdAt, status: .valid)
+                models.append(modelInfo)
+            }
+        } catch {
+            print("Failed to scan models: \(error)")
+        }
+    }
+
+    private func addModel(_ model: ModelsMeta.ModelInfo) {
+        guard !models.contains(where: { $0.id == model.id }) else { return }
+        models.insert(model, at: 0)
+        saveMeta()
+    }
+
+    private func removeModel(_ model: ModelsMeta.ModelInfo) {
+        models.removeAll { $0.id == model.id }
+        if lastLoadedModelId == model.id {
+            lastLoadedModelId = nil
+        }
+        saveMeta()
+    }
+
+    private func loadMeta() {
+        guard fileManager.fileExists(atPath: ModelsMeta.metaURL.path),
+              let data = try? Data(contentsOf: ModelsMeta.metaURL),
+              let meta = try? JSONDecoder().decode(ModelsMeta.self, from: data) else {
+            return
+        }
+        models = meta.models
+        lastLoadedModelId = meta.lastModelId
+    }
+
+    private func saveMeta() {
+        do {
+            try fileManager.createDirectoryIfNeeded(at: ModelsMeta.modelsDirectory)
+            let meta = ModelsMeta(models: models, lastModelId: lastLoadedModelId)
+            let encoder = JSONEncoder()
+            let data = try encoder.encode(meta)
+            try data.write(to: ModelsMeta.metaURL)
+        } catch {
+            print("Failed to save meta: \(error)")
+        }
+    }
+
+    private func saveThumbnail(_ image: NSImage, for model: ModelsMeta.ModelInfo) {
+        guard let tiffData = image.tiffRepresentation,
+              let bitmap = NSBitmapImageRep(data: tiffData),
+              let pngData = bitmap.representation(using: .png, properties: [:]) else {
+            return
+        }
+
+        do {
+            try pngData.write(to: model.rootURL.appending(path: ModelsMeta.ModelInfo.thumbnailFileName))
+        } catch {
+            print("Failed to save thumbnail: \(error)")
+        }
+    }
+}
+
+public enum ModelManagerError: Error {
+    case modelURLNotFound
+}

app/xcode/Sources/VCamData/ModelMetaLoader.swift

@@ -0,0 +1,86 @@
+import AppKit
+#if FEATURE_3
+import VRMKit
+#endif
+
+public struct ModelMeta: Hashable {
+    public var name: String
+    public var image: NSImage?
+}
+
+enum ModelMetaLoader {
+#if FEATURE_3
+    static func load(from url: URL) throws -> ModelMeta {
+        let loader = VRMLoader()
+        do {
+            let vrm1 = try loader.load(VRM1.self, withURL: url)
+            return ModelMeta(
+                name: vrm1.meta.name,
+                image: try? loader.loadThumbnail(from: vrm1)
+            )
+        } catch {
+            let vrm0 = try loader.load(VRM.self, withURL: url)
+            return ModelMeta(
+                name: vrm0.meta.title ?? url.deletingPathExtension().lastPathComponent,
+                image: try? loader.loadThumbnail(from: vrm0)
+            )
+        }
+    }
+#else
+    static func load(from url: URL) throws -> ModelMeta {
+        let modelJsonURL = resolveLive2DModelJSON(from: url)
+        let name = modelJsonURL.map { live2DModelName(from: $0) } ?? fallbackName(for: url)
+        return ModelMeta(name: name)
+    }
+
+    private static func resolveLive2DModelJSON(from url: URL) -> URL? {
+        let fileManager = FileManager.default
+        var isDirectory: ObjCBool = false
+
+        if fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) {
+            if isDirectory.boolValue {
+                return live2DModelJSON(in: url)
+            }
+            if isLive2DModelJSON(url) {
+                return url
+            }
+            return nil
+        }
+
+        return nil
+    }
+
+    private static func live2DModelJSON(in directory: URL) -> URL? {
+        guard let contents = try? FileManager.default.contentsOfDirectory(
+            at: directory,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]
+        ) else {
+            return nil
+        }
+
+        let candidates = contents
+            .filter { isLive2DModelJSON($0) }
+            .sorted { $0.lastPathComponent < $1.lastPathComponent }
+
+        return candidates.first
+    }
+
+    private static func isLive2DModelJSON(_ url: URL) -> Bool {
+        let fileName = url.lastPathComponent.lowercased()
+        return fileName.hasSuffix(".model3.json") || fileName.hasSuffix(".model.json")
+    }
+
+    private static func live2DModelName(from url: URL) -> String {
+        url.deletingPathExtension().deletingPathExtension().lastPathComponent
+    }
+
+    private static func fallbackName(for url: URL) -> String {
+        var isDirectory: ObjCBool = false
+        if FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory), !isDirectory.boolValue {
+            return url.deletingPathExtension().lastPathComponent
+        }
+        return url.lastPathComponent
+    }
+#endif
+}

app/xcode/Sources/VCamData/ModelsMeta.swift

@@ -0,0 +1,78 @@
+import AppKit
+import VCamEntity
+
+public struct ModelsMeta: Codable, Sendable {
+    var models: [ModelInfo]
+    var lastModelId: UUID?
+
+    public static var modelsDirectory: URL {
+        .applicationSupportDirectoryWithBundleID.appending(path: "models")
+    }
+
+#if FEATURE_3
+    public static let modelFileName = "model.vrm"
+    public static let modelType: ModelType = .vrm
+#else
+    public static let modelFileName = "live2d"
+    public static let modelType: ModelType = .live2d
+#endif
+
+    public static var metaURL: URL {
+        modelsDirectory.appending(path: "meta.json")
+    }
+
+    public static func modelDirectory(ofName name: String) -> URL {
+        modelsDirectory.appending(path: name)
+    }
+
+    public struct ModelInfo: Identifiable, Codable, Equatable, Hashable, Sendable {
+        public let id: UUID
+        public var name: String
+        public var displayName: String?
+        public let type: ModelType
+        public let createdAt: Date
+        public var status: ModelStatus
+
+        public enum ModelStatus: String, Codable, Hashable, Sendable {
+            case valid
+            case missing
+        }
+
+        public init(
+            id: UUID = UUID(),
+            name: String,
+            displayName: String? = nil,
+            type: ModelType,
+            createdAt: Date = .now,
+            status: ModelStatus = .valid
+        ) {
+            self.id = id
+            self.name = name
+            self.displayName = displayName
+            self.type = type
+            self.createdAt = createdAt
+            self.status = status
+        }
+
+        public var localizedName: String {
+            displayName ?? name
+        }
+    }
+}
+
+extension ModelsMeta.ModelInfo {
+    static var thumbnailFileName: String { "thumbnail.png" }
+
+    public var rootURL: URL {
+        ModelsMeta.modelDirectory(ofName: name)
+    }
+
+    public var modelURL: URL {
+        rootURL.appending(path: ModelsMeta.modelFileName)
+    }
+
+    public var thumbnail: NSImage? {
+        let thumbnailURL = rootURL.appending(path: Self.thumbnailFileName)
+        return NSImage(contentsOfFile: thumbnailURL.path)
+    }
+}