Skip to content

Free, open-source macOS cleaner. CleanMyMac alternative with zero telemetry. Native SwiftUI, scheduled auto-cleaning, Xcode/Homebrew/system cache cleanup. MIT licensed.

33.4 KB
Raw Blame
import XCTest
@testable import PureMac

final class XcodeBuildMCPDerivedDataSupportTests: XCTestCase {
    func testXcodeJunkIncludesManagedDerivedDataForEachWorkspace() async throws {
        try await assertXcodeJunkIncludesManagedDerivedDataForEachWorkspace(tool: "XcodeBuildMCP")
    }

    func testXcodeJunkIncludesMobileBuildMCPDerivedDataForEachWorkspace() async throws {
        try await assertXcodeJunkIncludesManagedDerivedDataForEachWorkspace(tool: "MobileBuildMCP")
    }

    private func assertXcodeJunkIncludesManagedDerivedDataForEachWorkspace(tool: String) async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let workspaceRoot = temporaryHome
            .appendingPathComponent("Library/Developer/\(tool)/workspaces/PureMac-59316969cafe", isDirectory: true)
        let derivedData = workspaceRoot.appendingPathComponent("DerivedData", isDirectory: true)
        let logs = workspaceRoot.appendingPathComponent("logs", isDirectory: true)
        let outsideDirectory = temporaryHome.appendingPathComponent("outside", isDirectory: true)
        let symlinkedDerivedData = temporaryHome
            .appendingPathComponent("Library/Developer/\(tool)/workspaces/Symlinked-111111111111/DerivedData")
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: logs, withIntermediateDirectories: true)
        try fileManager.createDirectory(
            at: symlinkedDerivedData.deletingLastPathComponent(),
            withIntermediateDirectories: true
        )
        try fileManager.createDirectory(at: outsideDirectory, withIntermediateDirectories: true)
        try fileManager.createSymbolicLink(at: symlinkedDerivedData, withDestinationURL: outsideDirectory)
        try Data(repeating: 0xAB, count: 4_096)
            .write(to: derivedData.appendingPathComponent("build-product"))
        try Data(repeating: 0xCD, count: 4_096)
            .write(to: logs.appendingPathComponent("build.log"))
        try Data(repeating: 0xEF, count: 4_096)
            .write(to: outsideDirectory.appendingPathComponent("must-not-be-scanned"))

        let engine = ScanEngine(homeDirectory: temporaryHome)
        let result = await engine.scanCategory(.xcodeJunk)

        let expectedPath = derivedData.resolvingSymlinksInPath().path
        let item = try XCTUnwrap(
            result.items.first {
                URL(fileURLWithPath: $0.path).resolvingSymlinksInPath().path == expectedPath
            },
            "Expected \(expectedPath); scanned: \(result.items.map(\.path))"
        )
        XCTAssertEqual(item.name, "\(tool): PureMac")
        XCTAssertFalse(item.isSelected)
        XCTAssertFalse(result.items.contains { $0.path == logs.path })
        XCTAssertFalse(result.items.contains { $0.path == symlinkedDerivedData.path })
    }

    func testSymlinkedXcodeBuildMCPRootIsNotScanned() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-RootLink-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let externalRoot = temporaryHome
            .appendingPathComponent("Library/Application Support/FakeXcodeBuildMCP", isDirectory: true)
        let externalDerivedData = externalRoot
            .appendingPathComponent("workspaces/Foreign-222222222222/DerivedData", isDirectory: true)
        let developerDirectory = temporaryHome
            .appendingPathComponent("Library/Developer", isDirectory: true)
        let managedRoot = developerDirectory.appendingPathComponent("XcodeBuildMCP", isDirectory: true)
        try fileManager.createDirectory(at: externalDerivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: developerDirectory, withIntermediateDirectories: true)
        try fileManager.createSymbolicLink(at: managedRoot, withDestinationURL: externalRoot)
        try Data(repeating: 0xAA, count: 4_096)
            .write(to: externalDerivedData.appendingPathComponent("foreign-data"))

        let result = await ScanEngine(homeDirectory: temporaryHome).scanCategory(.xcodeJunk)

        XCTAssertFalse(result.items.contains { $0.name.hasPrefix("XcodeBuildMCP:") })
    }

    func testCleaningRejectsManagedPathWhoseRootResolvesOutsideManagedStorage() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-CleanRootLink-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let externalRoot = temporaryHome
            .appendingPathComponent("Library/Application Support/FakeXcodeBuildMCP", isDirectory: true)
        let externalDerivedData = externalRoot
            .appendingPathComponent("workspaces/Foreign-222222222222/DerivedData", isDirectory: true)
        let developerDirectory = temporaryHome
            .appendingPathComponent("Library/Developer", isDirectory: true)
        let managedRoot = developerDirectory.appendingPathComponent("XcodeBuildMCP", isDirectory: true)
        let apparentDerivedData = managedRoot
            .appendingPathComponent("workspaces/Foreign-222222222222/DerivedData", isDirectory: true)
        try fileManager.createDirectory(at: externalDerivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: developerDirectory, withIntermediateDirectories: true)
        try fileManager.createSymbolicLink(at: managedRoot, withDestinationURL: externalRoot)
        try Data(repeating: 0xBB, count: 4_096)
            .write(to: externalDerivedData.appendingPathComponent("foreign-data"))

        let item = CleanableItem(
            name: "XcodeBuildMCP: Foreign",
            path: apparentDerivedData.path,
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: nil
        )
        let result = await CleaningEngine(homeDirectory: temporaryHome)
            .cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 0)
        XCTAssertTrue(fileManager.fileExists(atPath: externalDerivedData.path))
    }

    func testXcodeJunkIncludesLegacySharedDerivedData() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-Legacy-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let legacyDerivedData = temporaryHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP/DerivedData", isDirectory: true)
        try fileManager.createDirectory(at: legacyDerivedData, withIntermediateDirectories: true)
        try Data(repeating: 0xEF, count: 4_096)
            .write(to: legacyDerivedData.appendingPathComponent("legacy-build-product"))

        let result = await ScanEngine(homeDirectory: temporaryHome).scanCategory(.xcodeJunk)
        let expectedPath = legacyDerivedData.resolvingSymlinksInPath().path
        let item = try XCTUnwrap(result.items.first {
            URL(fileURLWithPath: $0.path).resolvingSymlinksInPath().path == expectedPath
        })

        XCTAssertEqual(item.name, "XcodeBuildMCP: Legacy DerivedData")
        XCTAssertFalse(item.isSelected)
    }

    func testCleaningLegacySharedDerivedDataMovesToTrashWithoutWorkspaceLock() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-LegacyClean-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let managedRoot = temporaryHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP", isDirectory: true)
        let legacyDerivedData = managedRoot.appendingPathComponent("DerivedData", isDirectory: true)
        try fileManager.createDirectory(at: legacyDerivedData, withIntermediateDirectories: true)
        try Data(repeating: 0xEF, count: 4_096)
            .write(to: legacyDerivedData.appendingPathComponent("legacy-build-product"))

        let scan = await ScanEngine(homeDirectory: temporaryHome).scanCategory(.xcodeJunk)
        let item = try XCTUnwrap(scan.items.first { $0.name == "XcodeBuildMCP: Legacy DerivedData" })
        let result = await CleaningEngine(homeDirectory: temporaryHome).cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 1)
        XCTAssertTrue(result.errors.isEmpty)
        XCTAssertFalse(fileManager.fileExists(atPath: legacyDerivedData.path))
        XCTAssertFalse(fileManager.fileExists(atPath: managedRoot.appendingPathComponent("locks").path))
        let trashedPath = try XCTUnwrap(result.trashedPaths.first)
        XCTAssertTrue(fileManager.fileExists(atPath: trashedPath))
        try? fileManager.removeItem(atPath: trashedPath)
    }

    func testCleaningManagedDerivedDataLeavesWorkspaceStateIntact() async throws {
        try await assertCleaningManagedDerivedDataLeavesWorkspaceStateIntact(tool: "XcodeBuildMCP")
    }

    func testCleaningMobileBuildMCPDerivedDataLeavesWorkspaceStateIntact() async throws {
        try await assertCleaningManagedDerivedDataLeavesWorkspaceStateIntact(tool: "MobileBuildMCP")
    }

    private func assertCleaningManagedDerivedDataLeavesWorkspaceStateIntact(tool: String) async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-Clean-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let workspaceRoot = temporaryHome
            .appendingPathComponent("Library/Developer/\(tool)/workspaces/PureMac-59316969cafe", isDirectory: true)
        let derivedData = workspaceRoot.appendingPathComponent("DerivedData", isDirectory: true)
        let preservedDirectories = ["logs", "state", "locks", "result-bundles", "test-products"].map {
            workspaceRoot.appendingPathComponent($0, isDirectory: true)
        }
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        for directory in preservedDirectories {
            try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
            try Data(repeating: 0xCD, count: 256)
                .write(to: directory.appendingPathComponent("must-survive"))
        }
        try Data(repeating: 0xAB, count: 4_096)
            .write(to: derivedData.appendingPathComponent("build-product"))

        let scan = await ScanEngine(homeDirectory: temporaryHome).scanCategory(.xcodeJunk)
        let item = try XCTUnwrap(scan.items.first { $0.name == "\(tool): PureMac" })
        let result = await CleaningEngine(homeDirectory: temporaryHome)
            .cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 1)
        XCTAssertFalse(fileManager.fileExists(atPath: derivedData.path))
        XCTAssertEqual(result.trashedPaths.count, 1)
        let trashedPath = try XCTUnwrap(result.trashedPaths.first)
        XCTAssertTrue(fileManager.fileExists(atPath: trashedPath))
        XCTAssertTrue(
            trashedPath.hasPrefix(
                fileManager.homeDirectoryForCurrentUser
                    .appendingPathComponent(".Trash", isDirectory: true)
                    .path + "/"
            )
        )
        try? fileManager.removeItem(atPath: trashedPath)
        for directory in preservedDirectories {
            XCTAssertTrue(fileManager.fileExists(atPath: directory.appendingPathComponent("must-survive").path))
        }
    }

    func testManagedDerivedDataSafetyOnlyAllowsDerivedDataDirectories() {
        let home = URL(fileURLWithPath: "/Users/tester", isDirectory: true)
        let managedRoot = "/Users/tester/Library/Developer/XcodeBuildMCP"

        XCTAssertTrue(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "\(managedRoot)/workspaces/PureMac-59316969cafe/DerivedData",
            homeDirectory: home
        ))
        XCTAssertTrue(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "\(managedRoot)/DerivedData",
            homeDirectory: home
        ))
        XCTAssertFalse(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "\(managedRoot)/workspaces/PureMac-59316969cafe/logs",
            homeDirectory: home
        ))
        XCTAssertFalse(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "\(managedRoot)/workspaces/PureMac-59316969cafe",
            homeDirectory: home
        ))
        XCTAssertFalse(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "\(managedRoot)-backup/workspaces/PureMac-59316969cafe/DerivedData",
            homeDirectory: home
        ))
        XCTAssertTrue(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "/Users/tester/Library/Developer/MobileBuildMCP/workspaces/PureMac-59316969cafe/DerivedData",
            homeDirectory: home
        ))
        XCTAssertFalse(XcodeBuildMCPDerivedDataSupport.isManagedDerivedDataPath(
            "/Users/tester/Library/Developer/MobileBuildMCP/workspaces/PureMac-59316969cafe/logs",
            homeDirectory: home
        ))
    }

    func testSymlinkedHomeScanOutputCanStillBeCleaned() async throws {
        let fileManager = FileManager.default
        let container = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-HomeLink-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: container) }

        let realHome = container.appendingPathComponent("real-home", isDirectory: true)
        let linkedHome = container.appendingPathComponent("linked-home", isDirectory: true)
        let derivedData = realHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData", isDirectory: true)
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: container, withIntermediateDirectories: true)
        try fileManager.createSymbolicLink(at: linkedHome, withDestinationURL: realHome)
        try Data(repeating: 0xA1, count: 4_096)
            .write(to: derivedData.appendingPathComponent("build-product"))

        let scan = await ScanEngine(homeDirectory: linkedHome).scanCategory(.xcodeJunk)
        let item = try XCTUnwrap(scan.items.first { $0.name == "XcodeBuildMCP: PureMac" })
        let result = await CleaningEngine(homeDirectory: linkedHome).cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 1)
        XCTAssertTrue(result.errors.isEmpty)
        XCTAssertFalse(fileManager.fileExists(atPath: derivedData.path))
    }

    func testCleaningRejectsDerivedDataSymlinkToAnotherManagedWorkspace() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-ManagedLink-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let workspaces = temporaryHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP/workspaces", isDirectory: true)
        let sourceWorkspace = workspaces.appendingPathComponent("Source-111111111111", isDirectory: true)
        let targetDerivedData = workspaces
            .appendingPathComponent("Target-222222222222/DerivedData", isDirectory: true)
        let apparentDerivedData = sourceWorkspace.appendingPathComponent("DerivedData", isDirectory: true)
        try fileManager.createDirectory(at: sourceWorkspace, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: targetDerivedData, withIntermediateDirectories: true)
        try Data(repeating: 0xB2, count: 4_096)
            .write(to: targetDerivedData.appendingPathComponent("must-survive"))
        try fileManager.createSymbolicLink(at: apparentDerivedData, withDestinationURL: targetDerivedData)

        let item = CleanableItem(
            name: "XcodeBuildMCP: Source",
            path: apparentDerivedData.path,
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: nil
        )
        let result = await CleaningEngine(homeDirectory: temporaryHome).cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 0)
        XCTAssertFalse(result.errors.isEmpty)
        XCTAssertTrue(fileManager.fileExists(atPath: targetDerivedData.appendingPathComponent("must-survive").path))
    }

    func testAdministratorCleaningNeverEscalatesManagedDerivedData() async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-NoAdmin-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let derivedData = temporaryHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData", isDirectory: true)
        let marker = derivedData.appendingPathComponent("must-survive")
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        try Data(repeating: 0xC3, count: 4_096).write(to: marker)
        let item = CleanableItem(
            name: "XcodeBuildMCP: PureMac",
            path: derivedData.path,
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: nil
        )

        let result = await CleaningEngine(homeDirectory: temporaryHome)
            .cleanWithAdminPrivileges(items: [item])

        XCTAssertEqual(result.itemsCleaned, 0)
        XCTAssertTrue(fileManager.fileExists(atPath: marker.path))
    }

    func testCleaningSkipsDerivedDataWhenLifecycleLockIsHeld() async throws {
        try await assertCleaningSkipsDerivedDataWhenLifecycleLockIsHeld(tool: "XcodeBuildMCP")
    }

    func testCleaningSkipsMobileBuildMCPDerivedDataWhenLifecycleLockIsHeld() async throws {
        try await assertCleaningSkipsDerivedDataWhenLifecycleLockIsHeld(tool: "MobileBuildMCP")
    }

    private func assertCleaningSkipsDerivedDataWhenLifecycleLockIsHeld(tool: String) async throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-Lock-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let workspaceRoot = temporaryHome
            .appendingPathComponent("Library/Developer/\(tool)/workspaces/PureMac-59316969cafe", isDirectory: true)
        let derivedData = workspaceRoot.appendingPathComponent("DerivedData", isDirectory: true)
        let lockDir = workspaceRoot
            .appendingPathComponent("locks/filesystem-lifecycle.lock", isDirectory: true)
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: lockDir, withIntermediateDirectories: true)
        try Data(repeating: 0xAB, count: 4_096)
            .write(to: derivedData.appendingPathComponent("build-product"))

        let nowMs = Date().timeIntervalSince1970 * 1000
        let owner: [String: Any] = [
            "token": UUID().uuidString,
            "pid": Int(getpid()),
            "purpose": "filesystem-lifecycle",
            "acquiredAtMs": nowMs,
            "expiresAtMs": nowMs + 600_000,
        ]
        let ownerData = try JSONSerialization.data(withJSONObject: owner)
        try ownerData.write(to: lockDir.appendingPathComponent("owner.json"))

        let item = CleanableItem(
            name: "\(tool): PureMac",
            path: derivedData.path,
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: nil
        )
        let result = await CleaningEngine(homeDirectory: temporaryHome)
            .cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 0)
        XCTAssertFalse(result.errors.isEmpty)
        XCTAssertTrue(fileManager.fileExists(atPath: derivedData.appendingPathComponent("build-product").path))
    }

    func testLifecycleLockDetectionMatchesXcodeBuildMCPOwnerFile() throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-LockDetect-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let derivedData = temporaryHome
            .appendingPathComponent("Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData", isDirectory: true)
        let lockDir = temporaryHome
            .appendingPathComponent(
                "Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/locks/filesystem-lifecycle.lock",
                isDirectory: true
            )
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)

        XCTAssertFalse(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )

        try fileManager.createDirectory(at: lockDir, withIntermediateDirectories: true)
        // A fresh lock directory without owner.json is treated as held — same
        // conservative stance XcodeBuildMCP takes within the lease window.
        XCTAssertTrue(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )

        let nowMs = Date().timeIntervalSince1970 * 1000
        let expiredOwner: [String: Any] = [
            "token": "abc",
            "pid": 4242,
            "purpose": "purge",
            "acquiredAtMs": nowMs - 1_200_000,
            "expiresAtMs": nowMs - 600_000,
        ]
        try JSONSerialization.data(withJSONObject: expiredOwner)
            .write(to: lockDir.appendingPathComponent("owner.json"))

        XCTAssertFalse(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )

        let liveOwner: [String: Any] = [
            "token": "def",
            "pid": 4242,
            "purpose": "purge",
            "acquiredAtMs": nowMs,
            "expiresAtMs": nowMs + 60_000,
        ]
        try JSONSerialization.data(withJSONObject: liveOwner)
            .write(to: lockDir.appendingPathComponent("owner.json"))

        XCTAssertTrue(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )
    }

    func testLifecycleLockAcquisitionIsExclusive() throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-LockAcquire-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let derivedData = temporaryHome
            .appendingPathComponent(
                "Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData",
                isDirectory: true
            )
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)

        let first = XcodeBuildMCPDerivedDataSupport.acquireLifecycleLock(
            forManagedDerivedDataPath: derivedData.path,
            homeDirectory: temporaryHome,
            fileManager: fileManager
        )
        XCTAssertNotNil(first)
        XCTAssertTrue(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager
            )
        )

        let second = XcodeBuildMCPDerivedDataSupport.acquireLifecycleLock(
            forManagedDerivedDataPath: derivedData.path,
            homeDirectory: temporaryHome,
            fileManager: fileManager
        )
        XCTAssertNil(second)

        if let first {
            XcodeBuildMCPDerivedDataSupport.releaseLifecycleLock(
                first,
                fileManager: fileManager
            )
        }
        XCTAssertFalse(
            XcodeBuildMCPDerivedDataSupport.isLifecycleLockHeld(
                forManagedDerivedDataPath: derivedData.path,
                homeDirectory: temporaryHome,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )
    }

    func testSymlinkedHomeAllowlistsOrdinaryCachesConsistently() async throws {
        let fileManager = FileManager.default
        let container = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-CacheHome-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: container) }

        let realHome = container.appendingPathComponent("real-home", isDirectory: true)
        let linkedHome = container.appendingPathComponent("linked-home", isDirectory: true)
        let cacheDir = realHome.appendingPathComponent("Library/Caches/com.example.junk", isDirectory: true)
        try fileManager.createDirectory(at: cacheDir, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: container, withIntermediateDirectories: true)
        try fileManager.createSymbolicLink(at: linkedHome, withDestinationURL: realHome)
        try Data(repeating: 0x11, count: 4_096)
            .write(to: cacheDir.appendingPathComponent("blob"))

        let item = CleanableItem(
            name: "com.example.junk",
            path: cacheDir.path,
            size: 4_096,
            category: .userCache,
            isSelected: true,
            lastModified: nil
        )
        let result = await CleaningEngine(homeDirectory: linkedHome).cleanItems([item]) { _ in }

        XCTAssertEqual(result.itemsCleaned, 1)
        XCTAssertTrue(result.errors.isEmpty)
        XCTAssertFalse(fileManager.fileExists(atPath: cacheDir.appendingPathComponent("blob").path))
    }

    func testSymlinkedHomeStillRefusesCloudProviderState() async throws {
        let fileManager = FileManager.default
        let container = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-ProviderHome-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: container) }

        let realHome = container.appendingPathComponent("real-home", isDirectory: true)
        let linkedHome = container.appendingPathComponent("linked-home", isDirectory: true)
        let birdCache = realHome.appendingPathComponent("Library/Caches/com.apple.bird", isDirectory: true)
        let cloudStorage = realHome.appendingPathComponent("Library/CloudStorage/Dropbox", isDirectory: true)
        let ordinaryCache = realHome.appendingPathComponent("Library/Caches/com.example.junk", isDirectory: true)
        for directory in [birdCache, cloudStorage, ordinaryCache] {
            try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
            try Data(repeating: 0x22, count: 4_096).write(to: directory.appendingPathComponent("blob"))
        }
        try fileManager.createSymbolicLink(at: linkedHome, withDestinationURL: realHome)

        let scan = await ScanEngine(homeDirectory: linkedHome).scanCategory(.userCache)
        XCTAssertTrue(scan.items.contains { $0.path.hasSuffix("/Library/Caches/com.example.junk") })
        XCTAssertFalse(scan.items.contains { $0.path.hasSuffix("/Library/Caches/com.apple.bird") })

        let items = [birdCache, cloudStorage].map { directory in
            CleanableItem(
                name: directory.lastPathComponent,
                path: directory.path,
                size: 4_096,
                category: .userCache,
                isSelected: true,
                lastModified: nil
            )
        }
        let result = await CleaningEngine(homeDirectory: linkedHome).cleanItems(items) { _ in }

        XCTAssertEqual(result.itemsCleaned, 0)
        XCTAssertTrue(result.cleanedPaths.isEmpty)
        XCTAssertEqual(result.errors.count, 2)
        for directory in [birdCache, cloudStorage] {
            XCTAssertTrue(fileManager.fileExists(atPath: directory.appendingPathComponent("blob").path))
        }
        XCTAssertTrue(ProviderPaths.isProviderOwned(birdCache.path, homeDirectory: linkedHome))
        XCTAssertTrue(ProviderPaths.isProviderOwned(
            linkedHome.appendingPathComponent("Library/CloudStorage/Dropbox").path,
            homeDirectory: linkedHome
        ))
    }

    func testScheduledAutoCleanAllowsOldUnlockedManagedDerivedData() {
        let item = CleanableItem(
            name: "XcodeBuildMCP: PureMac",
            path: "/Users/tester/Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData",
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: Date(timeIntervalSince1970: 0)
        )

        XCTAssertTrue(
            XcodeBuildMCPDerivedDataSupport.isEligibleForScheduledAutoClean(
                item,
                homeDirectory: URL(fileURLWithPath: "/Users/tester", isDirectory: true),
                now: Date(timeIntervalSince1970: XcodeBuildMCPDerivedDataSupport.scheduledCleanupAge + 1)
            )
        )
    }

    func testScheduledAutoCleanRejectsRecentManagedDerivedData() {
        let now = Date(timeIntervalSince1970: 10_000_000)
        let item = CleanableItem(
            name: "XcodeBuildMCP: PureMac",
            path: "/Users/tester/Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData",
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: now.addingTimeInterval(-XcodeBuildMCPDerivedDataSupport.scheduledCleanupAge + 1)
        )

        XCTAssertFalse(
            XcodeBuildMCPDerivedDataSupport.isEligibleForScheduledAutoClean(
                item,
                homeDirectory: URL(fileURLWithPath: "/Users/tester", isDirectory: true),
                now: now
            )
        )
    }

    func testScheduledAutoCleanRejectsManagedDerivedDataWithActiveLifecycleLock() throws {
        let fileManager = FileManager.default
        let temporaryHome = fileManager.temporaryDirectory
            .appendingPathComponent("PureMac-XcodeBuildMCP-ScheduledLock-\(UUID().uuidString)", isDirectory: true)
        defer { try? fileManager.removeItem(at: temporaryHome) }

        let derivedData = temporaryHome.appendingPathComponent(
            "Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/DerivedData",
            isDirectory: true
        )
        let lockDir = temporaryHome.appendingPathComponent(
            "Library/Developer/XcodeBuildMCP/workspaces/PureMac-59316969cafe/locks/filesystem-lifecycle.lock",
            isDirectory: true
        )
        try fileManager.createDirectory(at: derivedData, withIntermediateDirectories: true)
        try fileManager.createDirectory(at: lockDir, withIntermediateDirectories: true)

        let now = Date(timeIntervalSince1970: 10_000_000)
        let owner: [String: Any] = [
            "token": UUID().uuidString,
            "pid": 4242,
            "purpose": "filesystem-lifecycle",
            "acquiredAtMs": (now.timeIntervalSince1970 - 60) * 1000,
            "expiresAtMs": (now.timeIntervalSince1970 + 60) * 1000,
        ]
        try JSONSerialization.data(withJSONObject: owner)
            .write(to: lockDir.appendingPathComponent("owner.json"))

        let item = CleanableItem(
            name: "XcodeBuildMCP: PureMac",
            path: derivedData.path,
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: now.addingTimeInterval(-XcodeBuildMCPDerivedDataSupport.scheduledCleanupAge - 1)
        )

        XCTAssertFalse(
            XcodeBuildMCPDerivedDataSupport.isEligibleForScheduledAutoClean(
                item,
                homeDirectory: temporaryHome,
                now: now,
                fileManager: fileManager,
                isProcessAlive: { _ in false }
            )
        )
    }

    func testScheduledAutoCleanKeepsOrdinarySelectionSemantics() {
        let ordinary = CleanableItem(
            name: "DerivedData",
            path: "/Users/tester/Library/Developer/Xcode/DerivedData",
            size: 4_096,
            category: .xcodeJunk,
            isSelected: true,
            lastModified: nil
        )
        let home = URL(fileURLWithPath: "/Users/tester", isDirectory: true)

        XCTAssertTrue(
            XcodeBuildMCPDerivedDataSupport.isEligibleForScheduledAutoClean(ordinary, homeDirectory: home)
        )
    }
}