// SPDX-License-Identifier: GPL-3.0-or-later import Foundation import Darwin /// Recovery copies only. This store never writes to the project or guest media. /// Each editor session owns one file per project, so two apps cannot overwrite /// one another's drafts. Restore into a new session before discarding an old copy. final class CMOCWorkspaceRecovery: @unchecked Sendable { struct Draft: Codable, Equatable, Sendable { let path: String let text: String let savedText: String let savedHash: String init(path: String, text: String, savedText: String, savedHash: String) { self.path = path; self.text = text; self.savedText = savedText; self.savedHash = savedHash } } struct Record: Identifiable, Sendable { let id: UUID let projectPath: String let modifiedAt: Date let drafts: [Draft] let isFromRunningSession: Bool fileprivate let file: URL fileprivate let digest: String fileprivate let processID: Int32 } struct Scan: Sendable { let records: [Record] let issues: [String] } private struct Envelope: Codable { let version: Int let sessionID: UUID let processID: Int32 let projectPath: String let modifiedAt: Date let drafts: [Draft] } static let maximumDrafts = 128 static let maximumTextBytes = 16 * 1024 * 1024 static let maximumRecordBytes = 64 * 1024 * 1024 static let maximumScanRecords = 64 static let maximumScanTextBytes = 64 * 1024 * 1024 let root: URL let sessionID: UUID private let processID: Int32 private let canonicalRoot: URL private let lock = NSLock() init(root: URL, sessionID: UUID = UUID(), processID: Int32 = getpid()) { self.root = root.standardizedFileURL self.canonicalRoot = root.standardizedFileURL.resolvingSymlinksInPath() self.sessionID = sessionID; self.processID = processID } private func failure(_ message: String) -> CMOCBuildError { .message("Draft recovery: " + message) } private func projectPath(_ directory: URL) -> String { directory.standardizedFileURL.resolvingSymlinksInPath().path } private func kind(_ url: URL) throws -> FileAttributeType? { do { return try FileManager.default.attributesOfItem(atPath: url.path)[.type] as? FileAttributeType } catch let error as NSError where error.domain == NSCocoaErrorDomain && [NSFileReadNoSuchFileError, NSFileNoSuchFileError].contains(error.code) { return nil } } private func folder(for project: String, create: Bool) throws -> URL? { guard root.resolvingSymlinksInPath().path == canonicalRoot.path else { throw failure("The recovery folder location changed. Copies were left untouched.") } if let type = try kind(root) { guard type == .typeDirectory else { throw failure("The recovery folder must be a real directory, not a link.") } } else if create { try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700]) } else { return nil } let directory = root.appendingPathComponent(CMOCProject.sha256(Data(project.utf8)), isDirectory: true) if let type = try kind(directory) { guard type == .typeDirectory else { throw failure("A project recovery folder is a link or is not a directory.") } } else if create { try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700]) } else { return nil } return directory } private func validate(_ drafts: [Draft]) throws { guard drafts.count <= Self.maximumDrafts, Set(drafts.map { $0.path.lowercased() }).count == drafts.count else { throw failure("Too many drafts or duplicate draft paths. Existing copies were kept.") } var total = 0 for draft in drafts { try CMOCProject.validateRelativePath(draft.path) let text = try CMOCProject.sourceBytes(draft.text), saved = try CMOCProject.sourceBytes(draft.savedText) guard CMOCProject.sha256(saved) == draft.savedHash else { throw failure("The saved-file identity for \(draft.path) is inconsistent.") } total += text.count + saved.count guard total <= Self.maximumTextBytes else { throw failure("Drafts exceed the 16 MB recovery limit. Save your edits to the project.") } } } private func read(_ url: URL) throws -> Data { let descriptor = open(url.path, O_RDONLY | O_NOFOLLOW) guard descriptor >= 0 else { throw failure("Cannot safely read \(url.lastPathComponent).") } let handle = FileHandle(fileDescriptor: descriptor, closeOnDealloc: true) defer { try? handle.close() } var info = stat() guard fstat(descriptor, &info) == 0, (info.st_mode & S_IFMT) == S_IFREG, info.st_size >= 0, info.st_size <= Int64(Self.maximumRecordBytes) else { throw failure("\(url.lastPathComponent) is not a bounded regular recovery file.") } let data = try handle.read(upToCount: Self.maximumRecordBytes + 1) ?? Data() guard data.count <= Self.maximumRecordBytes else { throw failure("The recovery file grew beyond its size limit.") } return data } private func alive(_ pid: Int32) -> Bool { guard pid > 0 else { return false } return kill(pid, 0) == 0 || errno == EPERM } private func record(_ file: URL, project: String) throws -> Record { let data = try read(file) let envelope: Envelope do { envelope = try JSONDecoder().decode(Envelope.self, from: data) } catch { throw failure("\(file.lastPathComponent) is damaged or has an unsupported structure. The file was kept.") } guard envelope.version == 1, envelope.processID > 0, envelope.projectPath == project, file.lastPathComponent == envelope.sessionID.uuidString + ".json", envelope.modifiedAt.timeIntervalSince1970.isFinite else { throw failure("\(file.lastPathComponent) has an invalid recovery identity. The file was kept.") } try validate(envelope.drafts) return Record(id: envelope.sessionID, projectPath: project, modifiedAt: envelope.modifiedAt, drafts: envelope.drafts, isFromRunningSession: envelope.sessionID != sessionID && alive(envelope.processID), file: file, digest: CMOCProject.sha256(data), processID: envelope.processID) } func save(projectDirectory: URL, drafts: [Draft]) throws { lock.lock(); defer { lock.unlock() } try validate(drafts) let project = projectPath(projectDirectory) guard let directory = try folder(for: project, create: !drafts.isEmpty) else { return } let file = directory.appendingPathComponent(sessionID.uuidString + ".json") if let type = try kind(file), type != .typeRegular { throw failure("The session recovery file is not a regular file. It was kept.") } if drafts.isEmpty { if try kind(file) != nil { try FileManager.default.removeItem(at: file) } return } let envelope = Envelope(version: 1, sessionID: sessionID, processID: processID, projectPath: project, modifiedAt: Date(), drafts: drafts) let data = try JSONEncoder().encode(envelope) guard data.count <= Self.maximumRecordBytes else { throw failure("The encoded recovery copy exceeds its size limit. Existing copies were kept.") } try data.write(to: file, options: .atomic) } func scan(projectDirectory: URL) throws -> Scan { lock.lock(); defer { lock.unlock() } let project = projectPath(projectDirectory) guard let directory = try folder(for: project, create: false) else { return Scan(records: [], issues: []) } let files = try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil) guard files.count <= 1024 else { throw failure("Too many recovery files to inspect safely. Copies were left untouched.") } var records: [Record] = [], issues: [String] = [] var totalTextBytes = 0 for file in files.sorted(by: { $0.lastPathComponent < $1.lastPathComponent }) where file.pathExtension == "json" { guard records.count < Self.maximumScanRecords else { issues.append("Draft recovery: More than 64 saved sessions are present. Export or discard reviewed copies, then refresh to inspect the remaining sessions. All copies were kept.") break } do { let recovered = try record(file, project: project) let bytes = recovered.drafts.reduce(0) { $0 + $1.text.utf8.count + $1.savedText.utf8.count } guard totalTextBytes + bytes <= Self.maximumScanTextBytes else { issues.append("Draft recovery: Saved sessions exceed the 64 MB review limit. Export or discard reviewed copies, then refresh to inspect the remaining sessions. All copies were kept.") break } totalTextBytes += bytes; records.append(recovered) } catch { issues.append(error.localizedDescription) } } return Scan(records: records.sorted { $0.modifiedAt > $1.modifiedAt }, issues: issues) } func records(projectDirectory: URL) throws -> [Record] { let result = try scan(projectDirectory: projectDirectory) guard result.issues.isEmpty else { throw failure(result.issues.joined(separator: "\n")) } return result.records } func discard(_ record: Record) throws { lock.lock(); defer { lock.unlock() } guard let directory = try folder(for: record.projectPath, create: false), directory.appendingPathComponent(record.id.uuidString + ".json").resolvingSymlinksInPath().path == record.file.resolvingSymlinksInPath().path else { throw failure("The recovery record no longer belongs to this store.") } let current = try self.record(record.file, project: record.projectPath) guard current.digest == record.digest else { throw failure("This recovery copy changed after it was shown. Review it again before discarding.") } guard !current.isFromRunningSession else { throw failure("Another running editor session owns this recovery copy.") } try FileManager.default.removeItem(at: record.file) } }