// SPDX-License-Identifier: GPL-3.0-or-later import Foundation import Combine import AppKit #if !VCC_COMPANION_CLIENT /// Native review stays attached to its window and cannot strand shutdown on a /// canceled download/launch task waiting for a modal response. @MainActor final class LibraryReviewSheet { private let alert: NSAlert private let parent: NSWindow private var canceled = false init(alert: NSAlert, parent: NSWindow) { self.alert = alert; self.parent = parent } func present() async -> NSApplication.ModalResponse { await withTaskCancellationHandler { await withCheckedContinuation { done in guard !Task.isCancelled, !canceled, parent.attachedSheet == nil else { done.resume(returning: .cancel); return } alert.beginSheetModal(for: parent) { done.resume(returning: $0) } } } onCancel: { Task { @MainActor in self.canceled = true if self.alert.window.sheetParent === self.parent { self.parent.endSheet(self.alert.window, returnCode: .cancel) } } } } } #endif struct LibraryCategory: Identifiable, Sendable { let id: String let name: String let children: [LibraryCategory]? static func tree(_ paths: [String], prefix: String = "") -> [Self] { let names = Set(paths.compactMap { path -> String? in guard path.hasPrefix(prefix) else { return nil } return path.dropFirst(prefix.count).split(separator: "/").first.map(String.init) }) return names.sorted().map { name in let path = prefix + name let descendants = tree(paths.filter { $0.hasPrefix(path + "/") }, prefix: path + "/") return Self(id: path, name: name, children: descendants.isEmpty ? nil : descendants) } } } struct LibraryBrowseQuery: Equatable, Sendable { enum Scope: String, CaseIterable { case showcase, started, all, favorites, installed } enum Sort: String, CaseIterable { case title = "Title", modified = "Last Modified", size = "Download Size" } var scope: Scope = .started var text = "" var category = "" var softwareType = "" var media = "" var system = "" var evidence = "" var sort: Sort = .title var environment = "" var processor = "" var hardware = "" var hardwareUse = "" var displayFeature = "" static let environmentLabels = ["basic": "BASIC", "disk-basic": "Disk BASIC", "os9": "OS-9 / NitrOS-9", "unknown": "Environment unspecified"] static let processorLabels = ["6309": "Requires Hitachi 6309", "either": "Supports 6809 and 6309", "unknown": "Processor requirement unspecified"] static let hardwareLabels = ["speech-sound": "Speech/Sound", "orchestra90": "Orchestra-90", "joystick": "Joystick"] static let hardwareUseLabels = ["required": "Required", "optional": "Optional", "unspecified": "Requirement unspecified"] static let displayLabels = ["semigraphics": "Semigraphics", "SG-8": "Semigraphics-8", "SG-12": "Semigraphics-12", "SG-24": "Semigraphics-24"] var additionalFilterLabels: [String] { [Self.environmentLabels[environment], Self.processorLabels[processor], Self.hardwareLabels[hardware].map { label in hardwareUse.isEmpty ? label : label + " — " + (Self.hardwareUseLabels[hardwareUse] ?? hardwareUse) }, Self.displayLabels[displayFeature]].compactMap { $0 } } func matchesHardware(_ release: SoftwareLibraryRelease) -> Bool { hardware.isEmpty || (release.hardwareSupport[hardware] != nil && (hardwareUse.isEmpty || release.hardwareSupport[hardware] == hardwareUse)) } func matchesDisplay(_ release: SoftwareLibraryRelease) -> Bool { displayFeature.isEmpty || (displayFeature == "semigraphics" ? !release.semigraphicsModes.isEmpty : release.semigraphicsModes.contains(displayFeature)) } // Getting Started is an explicit catalog choice, independent of runtime // checks, provenance and former hard-coded starter selections. static func isGettingStarted(_ release: SoftwareLibraryRelease) -> Bool { release.gettingStarted } static func types(of release: SoftwareLibraryRelease, related: [SoftwareLibraryRelease] = []) -> [String] { release.browseCategories.isEmpty ? [type(of: release, related: related)] : release.browseCategories } static func matchesCategory(_ category: String, release: SoftwareLibraryRelease) -> Bool { if release.ownedGame != nil { return category.isEmpty || release.browseCategories.contains(category) } return category.isEmpty || release.category == category || release.category.hasPrefix(category + "/") || release.browseCategories.contains(category) } func matches(_ release: SoftwareLibraryRelease, titleName: String, related: [SoftwareLibraryRelease] = []) -> Bool { guard softwareType.isEmpty || Self.types(of: release, related: related).contains(softwareType), Self.matchesCategory(category, release: release), media.isEmpty || release.mediaType == media, system.isEmpty || release.system == system else { return false } guard environment.isEmpty || release.environment == environment, processor.isEmpty || release.processorRequirement == processor, matchesHardware(release), matchesDisplay(release) else { return false } switch evidence { case "checked": guard release.setup.status == "spot-checked" else { return false } case "manual": guard release.setup.status == "manual-setup" else { return false } case "notes": guard !release.setup.compatibilityNotes.isEmpty || !release.setup.configurationRequirements.isEmpty else { return false } default: break } let haystack = titleName + " " + release.searchText return text.split(whereSeparator: \.isWhitespace).allSatisfy { haystack.localizedStandardContains(String($0)) } } static func type(of release: SoftwareLibraryRelease, related: [SoftwareLibraryRelease] = []) -> String { if let primary = release.primaryBrowseCategory { return primary } func categoryType(_ release: SoftwareLibraryRelease) -> String? { let components = release.category.split(separator: "/").map(String.init) let names: Set = ["Applications", "Games", "Music", "Educational", "Demos", "Utilities", "Programming", "Magazines", "Books", "Pictures", "Hardware", "Operating Systems"] // The first software category is authoritative; a game's demo is still a game. if let name = components.first(where: names.contains) { return name } if components.contains(where: { $0.hasPrefix("NitrOS-9") || $0.hasPrefix("OS-9 L2") }) { return "Operating Systems" } if components.contains("Blank disks") || components.contains("Empty Hard Disk") { return "Blank Media" } return nil } if let own = categoryType(release) { return own } let types = Set(related.compactMap(categoryType)) return types.count == 1 ? types.first! : "Other" } func apply(to titles: [SoftwareLibraryTitle], favorites: Set, installed: Set) -> [LibraryBrowseRow] { var rows = titles.compactMap { title -> LibraryBrowseRow? in if scope == .favorites && !favorites.contains(title.id) { return nil } let matches = title.releases.filter { (scope != .started || Self.isGettingStarted($0)) && (scope != .showcase || $0.assets.contains(where: { SoftwareLibraryArtworkCache.canDisplay($0) })) && (scope != .installed || installed.contains($0.id)) && self.matches($0, titleName: title.name, related: title.releases) } guard !matches.isEmpty else { return nil } return LibraryBrowseRow(title: title, matchingReleases: matches) } rows.sort { a, b in let featuredGrouping = !category.isEmpty || !softwareType.isEmpty let aFeatured = featuredGrouping && a.categoryFeatured let bFeatured = featuredGrouping && b.categoryFeatured if aFeatured != bFeatured { return aFeatured } switch aFeatured ? .title : sort { case .modified: let av = a.matchingReleases.compactMap(\.modifiedAt).max() ?? "" let bv = b.matchingReleases.compactMap(\.modifiedAt).max() ?? "" if av != bv { return av > bv } case .size: let av = a.matchingReleases.map(\.byteSize).max() ?? 0 let bv = b.matchingReleases.map(\.byteSize).max() ?? 0 if av != bv { return av > bv } case .title: break } let order = a.title.name.localizedStandardCompare(b.title.name) return order == .orderedSame ? a.id < b.id : order == .orderedAscending } return rows } } struct LibraryBrowseRow: Identifiable, Sendable { let title: SoftwareLibraryTitle let matchingReleases: [SoftwareLibraryRelease] var id: String { title.id } var name: String { title.name } var categoryFeatured: Bool { matchingReleases.contains(where: \.categoryFeatured) } var formats: String { Set(matchingReleases.map(\.mediaLabel)).sorted().joined(separator: ", ") } var modified: String { matchingReleases.compactMap(\.modifiedAt).max() ?? "Unknown" } var size: String { ByteCountFormatter.string(fromByteCount: matchingReleases.map(\.byteSize).max() ?? 0, countStyle: .file) } } #if !VCC_COMPANION_CLIENT struct LibraryLaunchPreview: Identifiable { let id = UUID() let prepared: PreparedLibraryLaunch var plan: SoftwareLibraryLaunchPlan { prepared.plan } } #endif struct LibraryMediaChoice: Identifiable { let id = UUID() let release: SoftwareLibraryRelease let receipt: SoftwareLibraryInstallationReceipt let candidates: [CompanionLibraryDisk] } @MainActor final class SoftwareLibraryModel: ObservableObject { let state: SoftwareLibraryState let manual = SoftwareLibraryManualModel() let artworkDirectory: URL @Published private(set) var catalog: SoftwareLibraryCatalog? @Published private(set) var rows: [LibraryBrowseRow] = [] @Published private(set) var softwareTypes: [String] = [] @Published private(set) var categories: [LibraryCategory] = [] @Published private(set) var loading = false @Published private(set) var filtering = false @Published private(set) var error: String? @Published var query = LibraryBrowseQuery() { didSet { if query != oldValue { filter() } } } @Published var selection: String? @Published var layout = "Shelf" let companionAccess: (any CompanionLibraryAccess)? private let insertCompanionDisk: ((URL) async throws -> Void)? #if !VCC_COMPANION_CLIENT let installer: SoftwareLibraryInstaller let machine: MachineModel? private let sourceImporter: SoftwareLibrarySourceImporter private let sourceWorkspaceIdentity: (() -> UUID)? private let openSourceProject: ((URL, UUID, String?) async throws -> Bool)? @Published var launchPreview: LibraryLaunchPreview? #endif @Published var mediaChoice: LibraryMediaChoice? @Published private(set) var launchBusy = false @Published private(set) var launchError: String? @Published private(set) var launchMessage: String? #if !VCC_COMPANION_CLIENT @Published private(set) var previousSetup: ConfigurationProfile? #endif @Published private(set) var machineFocusRequest = 0 @Published private(set) var sourceFocusRequest = 0 @Published private(set) var importingSourceID: String? @Published private(set) var sourceImportMessage: String? @Published private(set) var sourceImportError: String? @Published private(set) var sourceImportFraction: Double? @Published private(set) var importedSourceDirectory: URL? @Published private(set) var sourceDetailsReleaseID: String? private var sourceImportGeneration = UUID() private var sourceImportTask: Task? private var launchTask: Task? @Published private(set) var installingReleaseID: String? @Published private(set) var installProgress: SoftwareLibraryInstallProgress? @Published private(set) var installationErrors: [String: String] = [:] @Published private(set) var installationNotice: String? @Published private(set) var recoveringInstallations = true private var installationGeneration = UUID() private var installationTask: Task? private var task: Task? private var generation = 0 private var subscriptions: Set = [] #if !VCC_COMPANION_CLIENT init(state: SoftwareLibraryState, artworkDirectory: URL? = nil, machine: MachineModel? = nil, sourceWorkspaceIdentity: (() -> UUID)? = nil, openSourceProject: ((URL, UUID, String?) async throws -> Bool)? = nil) { companionAccess = nil; insertCompanionDisk = nil self.state = state self.machine = machine self.sourceWorkspaceIdentity = sourceWorkspaceIdentity; self.openSourceProject = openSourceProject #if VCC_UI_TESTING sourceImporter = SoftwareLibrarySourceImporter(cacheDirectory: state.directory.appendingPathComponent("SourcePackages"), configuration: SoftwareLibraryInstallFixture.exclusiveEnabled ? SoftwareLibraryInstallFixture.sourceConfiguration : nil) #else sourceImporter = SoftwareLibrarySourceImporter(cacheDirectory: state.directory.appendingPathComponent("SourcePackages")) #endif #if VCC_UI_TESTING installer = SoftwareLibraryInstallFixture.enabled ? SoftwareLibraryInstallFixture.installer(root: state.directory) : SoftwareLibraryInstaller(root: state.directory) #else installer = SoftwareLibraryInstaller(root: state.directory) #endif #if VCC_UI_TESTING self.artworkDirectory = SoftwareLibraryInstallFixture.exclusiveEnabled ? state.directory.appendingPathComponent("FixtureArtwork") : artworkDirectory ?? FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0].appendingPathComponent("com.brianholman.vccplus.oss.mac/SoftwareLibrary/Artwork") if SoftwareLibraryInstallFixture.exclusiveEnabled { do { try SoftwareLibraryInstallFixture.seedExclusiveAssets(manualDirectory: state.directory.appendingPathComponent("Manuals"), artworkDirectory: self.artworkDirectory) } catch { self.error = error.localizedDescription } } #else self.artworkDirectory = artworkDirectory ?? FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0].appendingPathComponent("com.brianholman.vccplus.oss.mac/SoftwareLibrary/Artwork") #endif state.objectWillChange.sink { [weak self] in Task { @MainActor [weak self] in self?.objectWillChange.send(); self?.filter() } }.store(in: &subscriptions) } #endif init(companion: any CompanionLibraryAccess, onInsertDisk: @escaping (URL) async throws -> Void) { companionAccess = companion; insertCompanionDisk = onInsertDisk state = SoftwareLibraryState(companion: companion) artworkDirectory = FileManager.default.temporaryDirectory.appendingPathComponent("VCCCompanionPresentation") #if !VCC_COMPANION_CLIENT machine = nil; installer = SoftwareLibraryInstaller(root: state.directory) sourceWorkspaceIdentity = nil; openSourceProject = nil sourceImporter = SoftwareLibrarySourceImporter(cacheDirectory: state.directory.appendingPathComponent("SourcePackages")) #endif // A disk companion starts with all eligible software, including titles // without cover art. Later snapshots preserve explicit scope choices. query = LibraryBrowseQuery(scope: .all) state.objectWillChange.sink { [weak self] in Task { @MainActor [weak self] in self?.objectWillChange.send(); self?.filter() } }.store(in: &subscriptions) } var isDiskCompanion: Bool { companionAccess != nil } var canOpenSource: Bool { #if !VCC_COMPANION_CLIENT return !isDiskCompanion && sourceWorkspaceIdentity != nil && openSourceProject != nil #else return false #endif } func chooseSourceDestination(_ release: SoftwareLibraryRelease) { #if !VCC_COMPANION_CLIENT guard canOpenSource, release.ownedGame != nil, importingSourceID == nil else { return } let panel = NSSavePanel() panel.title = "Save Source Project"; panel.prompt = "Download Source" panel.message = "Choose a new personal project folder. Opening source does not build, run or change the CoCo." panel.canCreateDirectories = true panel.nameFieldStringValue = (selectedRow?.name ?? "CoCo") + " Source" panel.begin { [weak self] response in guard response == .OK, let directory = panel.url else { return } self?.importSource(release, to: directory) } #endif } func importSource(_ release: SoftwareLibraryRelease, to directory: URL) { #if !VCC_COMPANION_CLIENT guard importingSourceID == nil, let source = release.ownedGame?.source, let expected = sourceWorkspaceIdentity?(), let openSourceProject else { return } importingSourceID = release.id; sourceImportMessage = "Downloading source…" sourceDetailsReleaseID = release.id let attempt = UUID(); sourceImportGeneration = attempt sourceImportError = nil; sourceImportFraction = nil; importedSourceDirectory = nil sourceImportTask = Task { defer { importingSourceID = nil; sourceImportTask = nil; sourceImportFraction = nil } do { let result = try await sourceImporter.importProject(source, to: directory) { progress in Task { @MainActor in guard self.importingSourceID == release.id, self.sourceImportGeneration == attempt else { return } self.sourceImportFraction = progress.fraction switch progress.stage { case .downloading: self.sourceImportMessage = "Downloading source…" case .verifying: self.sourceImportMessage = "Verifying source…" case .extracting: self.sourceImportMessage = "Preparing source files…" case .checking: self.sourceImportMessage = "Checking the C project…" case .complete: break } } } importedSourceDirectory = result.importedDirectory try Task.checkCancellation() let opened = try await openSourceProject(result.projectDirectory, expected, source.buildConfiguration) sourceImportMessage = opened ? "Your source copy is open in C Development. Build when you are ready." : "Your source copy is saved. The current C project is still open." if opened { sourceFocusRequest += 1 } } catch is CancellationError { sourceImportMessage = importedSourceDirectory == nil ? "Source download canceled." : "Your source copy is saved." } catch { sourceImportError = error.localizedDescription; sourceImportMessage = nil } } #endif } func cancelSourceImport() { sourceImportTask?.cancel() } var canLaunch: Bool { if insertCompanionDisk != nil { return true } #if !VCC_COMPANION_CLIENT return machine != nil #else return false #endif } var hasPreviousSetup: Bool { #if !VCC_COMPANION_CLIENT return previousSetup != nil #else return false #endif } var hasPendingLaunch: Bool { #if !VCC_COMPANION_CLIENT return launchPreview != nil || mediaChoice != nil #else return mediaChoice != nil #endif } func launchLabel(_ release: SoftwareLibraryRelease, installed: Bool) -> String { if isDiskCompanion { return installed ? "Insert Disk…" : "Download & Insert…" } #if !VCC_COMPANION_CLIENT if release.ownedGame?.firstPlayColdDOS == true { return installed ? "Play" : "Download & Play" } return SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: release) ? (installed ? "Play…" : "Download & Play…") : (installed ? "Set Up…" : "Download & Set Up…") #else return "Insert Disk…" #endif } func launchSymbol(_ release: SoftwareLibraryRelease) -> String { if isDiskCompanion { return "externaldrive" } #if !VCC_COMPANION_CLIENT return SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: release) ? "play.fill" : "desktopcomputer" #else return "externaldrive" #endif } func focusDisplay() { #if !VCC_COMPANION_CLIENT machine?.focusDisplay() #endif } func load(from url: URL? = SoftwareLibraryCatalog.bundledURL()) async { guard catalog == nil, !loading else { return } loading = true; error = nil if let companionAccess { defer { loading = false; recoveringInstallations = false } do { let response = try await companionAccess.libraryRequest(.init(operation: .snapshot)) try acceptCompanion(response) guard catalog != nil else { throw CompanionLibraryFailure(message: "VCC Plus did not return its disk catalog.") } } catch { self.error = error.localizedDescription } return } #if !VCC_COMPANION_CLIENT await refreshInstallations() #if VCC_UI_TESTING if SoftwareLibraryInstallFixture.enabled { catalog = SoftwareLibraryInstallFixture.catalog categories = LibraryCategory.tree(catalog!.categories) updateSoftwareTypes(catalog!) query.scope = .all filter(); loading = false; return } #endif do { guard let url else { throw SoftwareLibraryCatalog.Failure.missing } let snapshot = try await SoftwareLibraryCatalog.load(from: url) catalog = snapshot; categories = LibraryCategory.tree(snapshot.categories); updateSoftwareTypes(snapshot); filter() } catch { self.error = error.localizedDescription } loading = false #endif } private func acceptCompanion(_ response: CompanionLibraryResponse) throws { if let message = response.errorMessage { throw CompanionLibraryFailure(message: message) } if let snapshot = response.snapshot { // The service filters too; defend the UI and edition picker independently. let filtered = snapshot.catalog.companionDisksOnly catalog = filtered; categories = LibraryCategory.tree(filtered.categories) updateSoftwareTypes(filtered); state.applyRemoteSnapshot(snapshot); filter() } } var selectedRow: LibraryBrowseRow? { rows.first { $0.id == selection } } var selectedRelease: SoftwareLibraryRelease? { guard let row = selectedRow else { return nil } if let preferred = state.preferredReleaseID(for: row.id), let release = row.matchingReleases.first(where: { $0.id == preferred }) { return release } return row.matchingReleases.first } func chooseRelease(_ id: String) { guard let title = selectedRow?.title, let chosen = title.releases.first(where: { $0.id == id }) else { return } // Keep the user's context when another edition still matches it. Clear // only constraints that would hide their explicit edition choice. var next = query if !next.softwareType.isEmpty && !LibraryBrowseQuery.types(of: chosen, related: title.releases).contains(next.softwareType) { next.softwareType = "" } if !next.category.isEmpty && !LibraryBrowseQuery.matchesCategory(next.category, release: chosen) { next.category = "" } if !next.media.isEmpty && chosen.mediaType != next.media { next.media = "" } if !next.system.isEmpty && chosen.system != next.system { next.system = "" } if !next.environment.isEmpty && chosen.environment != next.environment { next.environment = "" } if !next.processor.isEmpty && chosen.processorRequirement != next.processor { next.processor = "" } if !next.matchesHardware(chosen) { next.hardware = ""; next.hardwareUse = "" } if !next.matchesDisplay(chosen) { next.displayFeature = "" } if !LibraryBrowseQuery(scope: .all, evidence: next.evidence).matches(chosen, titleName: title.name) { next.evidence = "" } if !LibraryBrowseQuery(scope: .all, text: next.text).matches(chosen, titleName: title.name) { next.text = "" } if next.scope == .started && !LibraryBrowseQuery.isGettingStarted(chosen) { next.scope = .all } if next.scope == .showcase && !chosen.assets.contains(where: { SoftwareLibraryArtworkCache.canDisplay($0) }) { next.scope = .all } if next.scope == .installed && state.installedReleases[id] == nil { next.scope = .all } state.selectRelease(id, for: title.id) query = next } func browse(_ scope: LibraryBrowseQuery.Scope, category: String = "") { var next = query next.scope = scope; next.category = category; next.softwareType = "" query = next } private func updateSoftwareTypes(_ catalog: SoftwareLibraryCatalog) { softwareTypes = Array(Set(catalog.titles.flatMap { title in title.releases.flatMap { LibraryBrowseQuery.types(of: $0, related: title.releases) } })).sorted() } func browseType(_ type: String) { var next = query next.scope = .all; next.category = ""; next.softwareType = type query = next } func clearFilters() { var next = query next.softwareType = ""; next.media = ""; next.system = ""; next.evidence = "" next.environment = ""; next.processor = ""; next.hardware = ""; next.hardwareUse = ""; next.displayFeature = "" query = next } func install(_ release: SoftwareLibraryRelease, playAfter: Bool = false) { guard installingReleaseID == nil, !recoveringInstallations, !launchBusy, !hasPendingLaunch else { return } if companionAccess != nil { installCompanion(release, insertAfter: playAfter); return } #if !VCC_COMPANION_CLIENT installationErrors[release.id] = nil; installationNotice = nil installingReleaseID = release.id; installProgress = nil let attempt = UUID(); installationGeneration = attempt installationTask = Task { do { let receipt = try await installer.install(release) { progress in Task { @MainActor in guard self.installingReleaseID == release.id, self.installationGeneration == attempt else { return } self.installProgress = progress } } await refreshInstallations() if playAfter, !Task.isCancelled { await prepareLaunch(release, receipt: receipt) } } catch { if Task.isCancelled || error is CancellationError { installationNotice = "Download canceled. You can try again whenever you’re ready." } else { installationErrors[release.id] = error.localizedDescription } } installingReleaseID = nil; installProgress = nil; installationTask = nil } #endif } func cancelInstallation() { installationTask?.cancel() if let companionAccess, let id = installingReleaseID { Task { _ = try? await companionAccess.libraryRequest(.init(operation: .cancelInstallation, releaseID: id)) } } } func shutdown() async { sourceImportTask?.cancel() await sourceImportTask?.value launchTask?.cancel() await launchTask?.value cancelInstallation() await installationTask?.value await state.flush() } func removeInstallation(_ id: String) async { guard installingReleaseID == nil, !launchBusy, !hasPendingLaunch else { return } if let companionAccess { do { try acceptCompanion(try await companionAccess.libraryRequest(.init(operation: .removeInstallation, releaseID: id))) } catch { installationErrors[id] = error.localizedDescription } return } #if !VCC_COMPANION_CLIENT do { if let retained = try await installer.forgetInstallation(releaseID: id) { installationNotice = "Removed from the Library. Your files are still in \(retained.path)." } await refreshInstallations() } catch { installationErrors[id] = error.localizedDescription } #endif } func play(_ release: SoftwareLibraryRelease) { guard canLaunch else { return } launchError = nil; launchMessage = nil install(release, playAfter: true) } #if !VCC_COMPANION_CLIENT private func prepareLaunch(_ release: SoftwareLibraryRelease, receipt: SoftwareLibraryInstallationReceipt, selectedMember: String? = nil) async { guard let machine else { return } launchBusy = true defer { launchBusy = false } do { let plan = try await Task.detached(priority: .userInitiated) { try SoftwareLibraryLaunchPlan.prepare(release: release, receipt: receipt, selectedMember: selectedMember) }.value try Task.checkCancellation() let prepared = try await machine.prepareLibraryLaunch(plan) try Task.checkCancellation() if plan.usesCuratedStartup { let snapshot = await machine.mcpReadinessSnapshot() try Task.checkCancellation() if Self.needsCuratedRestartReview(snapshot, hasRAMDisk: machine.cartridgeAssignments.slots.contains(where: { $0.kind == .ramDisk })) { let alert = NSAlert() alert.messageText = "Restart the current CoCo to play “\(plan.title)”?" alert.informativeText = "The current program and RAM disk contents will be cleared. Save any program you want to keep first. Writable disk changes are saved; unsaved temporary media or recordings block the restart." alert.addButton(withTitle: "Restart & Play"); alert.addButton(withTitle: "Cancel") guard let parent = NSApp.keyWindow else { throw ProfileFailure.message("Open the Software Library to review the current program before restarting.") } let response = await LibraryReviewSheet(alert: alert, parent: parent).present() guard response == .alertFirstButtonReturn else { return } } try Task.checkCancellation() let result = try await machine.launchLibrary(prepared) previousSetup = prepared.previousSetup launchMessage = result.message ?? "Started " + plan.title + "." machineFocusRequest += 1 } else { launchPreview = LibraryLaunchPreview(prepared: prepared) } } catch SoftwareLibraryLaunchPlan.Failure.needsSelection(let candidates) { guard !Task.isCancelled else { return } mediaChoice = LibraryMediaChoice(release: release, receipt: receipt, candidates: candidates.map { CompanionLibraryDisk(path: $0.path, mediaType: $0.mediaType) }) } catch { if !Task.isCancelled { launchError = error.localizedDescription } } } static func needsCuratedRestartReview(_ snapshot: VCCMachineSnapshot, hasRAMDisk: Bool = false) -> Bool { if hasRAMDisk { return true } if snapshot.state == .empty { return false } return snapshot.assistantEmptyBASIC?.boolValue != true || snapshot.assistantDirectPrompt?.boolValue != true || snapshot.debuggerDevelopmentAttached || snapshot.basicDebugAttached || snapshot.debuggerAssemblyAttached || snapshot.pasteRemaining > 0 } func confirmLaunch() { guard let preview = launchPreview, let machine, !launchBusy else { return } launchPreview = nil; launchBusy = true; launchError = nil; launchMessage = nil launchTask = Task { defer { launchBusy = false; launchTask = nil } do { let result = try await machine.launchLibrary(preview.prepared) previousSetup = preview.prepared.previousSetup launchMessage = result.message ?? (preview.plan.automaticallyStarts ? "Started " + preview.plan.title + "." : "The media is mounted. Follow the loading instructions to start the software.") machineFocusRequest += 1 } catch { launchError = error.localizedDescription } } } func returnToPreviousSetup() { guard let profile = previousSetup, let machine, !launchBusy, installingReleaseID == nil, launchPreview == nil, mediaChoice == nil else { return } launchBusy = true; launchError = nil; launchMessage = nil launchTask = Task { defer { launchBusy = false; launchTask = nil } do { try await machine.returnLibrarySetup(profile) previousSetup = nil; launchMessage = "Previous setup restored. Its prior running program and memory are not restored." machineFocusRequest += 1 } catch { launchError = error.localizedDescription } } } private func refreshInstallations() async { recoveringInstallations = true defer { recoveringInstallations = false } do { let receipts = try await installer.recoverInstallations() let warnings = await installer.recoveryWarnings if !warnings.isEmpty { installationNotice = warnings.joined(separator: "\n") } state.replaceInstallations(receipts.map { .init(releaseID: $0.releaseID, packageSHA256: $0.packageSHA256, installedAt: $0.installedAt, workingDirectory: $0.workingDirectory) }) } catch { installationNotice = "Installed software could not be checked: " + error.localizedDescription } } #endif func chooseLaunchMember(_ member: String, choice: LibraryMediaChoice) { guard !launchBusy else { return } mediaChoice = nil if companionAccess != nil { launchTask = Task { await prepareCompanionDisk(choice.release, selectedMember: member) } return } #if !VCC_COMPANION_CLIENT launchTask = Task { await prepareLaunch(choice.release, receipt: choice.receipt, selectedMember: member) launchTask = nil } #endif } func stopAutomaticLoading() { launchTask?.cancel(); cancelInstallation() } #if VCC_COMPANION_CLIENT func returnToPreviousSetup() { } #endif private func installCompanion(_ release: SoftwareLibraryRelease, insertAfter: Bool) { guard let companionAccess, release.mediaType == "disk" else { return } installationErrors[release.id] = nil; installationNotice = nil installingReleaseID = release.id; installProgress = nil let attempt = UUID(); installationGeneration = attempt installationTask = Task { defer { if installationGeneration == attempt { installingReleaseID = nil; installProgress = nil; installationTask = nil } } do { var response = try await companionAccess.libraryRequest(.init(operation: .install, releaseID: release.id)) while true { try Task.checkCancellation() guard installationGeneration == attempt else { return } try acceptCompanion(response); installProgress = response.progress if !response.isInstalling { break } try await Task.sleep(nanoseconds: 350_000_000) response = try await companionAccess.libraryRequest(.init(operation: .installStatus, releaseID: release.id)) } guard state.installedReleases[release.id] != nil else { throw CompanionLibraryFailure(message: "The installation did not complete. Your existing files have been preserved.") } if insertAfter { await prepareCompanionDisk(release) } } catch { if Task.isCancelled || error is CancellationError { installationNotice = "Download canceled. You can try again whenever you’re ready." } else { installationErrors[release.id] = error.localizedDescription } } } } private func prepareCompanionDisk(_ release: SoftwareLibraryRelease, selectedMember: String? = nil) async { guard let companionAccess, let insertCompanionDisk, release.mediaType == "disk" else { return } launchBusy = true; launchError = nil; launchMessage = nil defer { launchBusy = false } do { let response = try await companionAccess.libraryRequest(.init(operation: .diskMembers, releaseID: release.id)) try acceptCompanion(response) let candidates = response.disks ?? [] let chosen: String if let selectedMember, candidates.contains(where: { $0.path == selectedMember }) { chosen = selectedMember } else if candidates.count == 1 { chosen = candidates[0].path } else if candidates.count > 1 { guard let receipt = response.receipt else { throw CompanionLibraryFailure(message: "VCC Plus did not return the installation record.") } mediaChoice = LibraryMediaChoice(release: release, receipt: receipt, candidates: candidates) return } else { throw CompanionLibraryFailure(message: "This installation has no supported floppy disk image.") } let exported = try await companionAccess.libraryRequest(.init(operation: .exportDisk, releaseID: release.id, memberPath: chosen)) try acceptCompanion(exported); try Task.checkCancellation() guard let url = exported.exportedDiskURL, url.isFileURL else { throw CompanionLibraryFailure(message: "VCC Plus did not return a disk copy.") } try await insertCompanionDisk(url) launchMessage = "The disk is inserted. Follow the loading instructions on your CoCo." } catch { if !Task.isCancelled { launchError = error.localizedDescription } } } private func filter() { guard let catalog else { return } task?.cancel(); generation += 1; let version = generation let query = query, favorites = state.favoriteTitleIDs, installed = Set(state.installedReleases.keys) filtering = true task = Task { // Debounce typing without blocking the machine's UI or audio queues. do { try await Task.sleep(nanoseconds: 90_000_000) } catch { return } let worker = Task.detached(priority: .userInitiated) { query.apply(to: catalog.titles, favorites: favorites, installed: installed) } let result = await worker.value guard !Task.isCancelled, version == generation else { return } rows = result; filtering = false if !rows.contains(where: { $0.id == selection }) { selection = rows.first?.id } } } }