Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,337 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import CryptoKit
/// A bounded interpretation of catalog data, not executable host instructions.
/// Preparation reads only the installed Working tree and never changes the machine.
struct SoftwareLibraryLaunchPlan: Sendable {
enum Profile: String, Sendable { case diskBasic = "disk-basic", romCartridge = "rom-cartridge", cocoSDC = "coco-sdc" }
enum CartridgeDevice: String, Sendable { case rom, orchestra90 }
struct Candidate: Identifiable, Equatable, Sendable {
let path: String
let mediaType: String
var id: String { path }
var label: String { path }
}
enum Failure: LocalizedError {
case invalidRecipe(String), unsafeMedia(String), missingMedia(String), unsupported(String), needsSelection([Candidate])
var errorDescription: String? {
switch self {
case .invalidRecipe(let detail): return "This edition’s setup needs attention. " + detail
case .unsafeMedia(let detail): return "The installed media contains an unsafe file reference. " + detail
case .missingMedia(let detail): return "An installed file is missing. " + detail
case .unsupported(let detail): return detail
case .needsSelection: return "Choose the installed file to mount first. The catalog does not identify a startup file."
}
}
}
let workingDirectory: URL
private let canonicalWorkingDirectory: URL
let releaseID: String
let title: String
let profile: Profile
let use6309: Bool
let ramKiB: Int
let ramIndex: Int
let videoOutput: Int?
let controllerSlot: Int
let cartridgeDevice: CartridgeDevice
let floppyURLs: [Int: URL]
let cassetteURL: URL?
let cartridgeURL: URL?
let sdcFolderURL: URL?
let sdcInitialImages: [Int: String]
/// Plain BASIC lines without CR; the machine controller waits for readiness between lines.
let commands: [String]
let manualInstructions: String
let compatibilityNotes: [String]
let automaticallyStarts: Bool
let controls: LibraryJSON
private let curatedStartup: SoftwareLibraryOwnedGame?
var usesCuratedStartup: Bool { curatedStartup != nil }
private static func supportsDisk(_ ext: String, profile: Profile) -> Bool {
switch profile {
case .diskBasic: return DiskFiles.extensions.contains(ext)
case .cocoSDC: return ["dsk", "jvc", "os9"].contains(ext)
case .romCartridge: return false
}
}
/// Presentation only: downloaded files still undergo full preparation before
/// a restart is offered. Missing or ambiguous startup media remains Set Up.
static func hasAutomaticStartup(for release: SoftwareLibraryRelease) -> Bool {
guard let name = release.setup.configuration["profile"].string,
let profile = Profile(rawValue: name),
case .array(let members) = release.setup.selectedMembers,
!members.isEmpty, members.count <= 4 else { return false }
guard (try? recommendedCartridgeDevice(release.setup.configuration, profile: profile)) != nil else { return false }
var targets = Set<String>()
for member in members {
guard let path = member["path"].string, validRelative(path),
let target = member["target"].string, targets.insert(target).inserted else { return false }
let ext = (path as NSString).pathExtension.lowercased()
switch profile {
case .romCartridge:
guard members.count == 1, target == "cartridge", ["ccc", "rom"].contains(ext) else { return false }
case .diskBasic:
guard (target == "media" && ["cas", "wav"].contains(ext)) ||
(["disk0", "disk1", "disk2", "disk3"].contains(target) && Self.supportsDisk(ext, profile: profile)) else { return false }
case .cocoSDC:
guard ["disk0", "disk1"].contains(target), Self.supportsDisk(ext, profile: profile) else { return false }
}
}
return profile == .romCartridge || decodeCommands(release.setup.command)?.contains(where: startsSoftware) == true
}
static func prepare(release: SoftwareLibraryRelease, receipt: SoftwareLibraryInstallationReceipt,
selectedMember: String? = nil) throws -> Self {
try release.validatePresentationMetadata()
guard receipt.releaseID == release.id, receipt.packageSHA256 == release.packageSHA256,
receipt.workingDirectory.isFileURL, receipt.workingDirectory.host.map({ $0.isEmpty || $0 == "localhost" }) != false,
receipt.workingDirectory.query == nil, receipt.workingDirectory.fragment == nil,
receipt.workingDirectory.lastPathComponent == "Working" else {
throw Failure.invalidRecipe("The installation does not match this catalog edition.")
}
let config = release.setup.configuration
guard let profileName = config["profile"].string, let profile = Profile(rawValue: profileName) else {
throw Failure.unsupported("This edition needs a custom machine setup. Its installed files and loading notes remain available.")
}
let cartridgeDevice = try recommendedCartridgeDevice(config, profile: profile)
for key in ["processor", "video"] where config[key] != .null {
guard config[key].string != nil else { throw Failure.invalidRecipe("Invalid " + key + " recommendation.") }
}
for key in ["ram_kib", "controller_slot", "cartridge_slot"] where config[key] != .null {
guard config[key].integer != nil else { throw Failure.invalidRecipe("Invalid " + key + " recommendation.") }
}
let cpu = config["processor"].string ?? "6809"
guard cpu == "6809" || cpu == "6309" else { throw Failure.invalidRecipe("Unsupported processor recommendation.") }
let ram = config["ram_kib"].integer ?? 2048
guard let ramIndex = [128, 512, 2048, 8192].firstIndex(of: ram) else { throw Failure.invalidRecipe("Unsupported memory recommendation.") }
let slot = (profile == .romCartridge ? config["cartridge_slot"].integer : nil) ?? config["controller_slot"].integer ?? 4
guard (1...4).contains(slot) else { throw Failure.invalidRecipe("The startup slot must be 1 through 4.") }
let video: Int?
switch config["video"].string {
case "rgb": video = 0
case "composite": video = 1
case nil: video = nil
default: throw Failure.invalidRecipe("Unsupported video recommendation.")
}
let root = receipt.workingDirectory.standardizedFileURL
try checkDirectory(root)
let known = Set(receipt.relativeFiles)
guard known.count == receipt.relativeFiles.count, receipt.relativeFiles.count <= 20_000,
receipt.relativeFiles.allSatisfy(validRelative) else { throw Failure.unsafeMedia("The installation inventory is invalid.") }
var selected: [(target: String, path: String)] = []
guard case .array(let members) = release.setup.selectedMembers else { throw Failure.invalidRecipe("The startup media list is invalid.") }
for member in members {
guard let path = member["path"].string, let target = member["target"].string,
validRelative(path), known.contains(path) else { throw Failure.invalidRecipe("The startup file is not in this installation.") }
selected.append((target, path))
}
// A user chooses only when the recipe has no selected startup media.
// Unlabelled .bin files are never guessed to be ROM cartridges.
if selected.isEmpty {
let candidates = receipt.relativeFiles.compactMap { path -> Candidate? in
let ext = (path as NSString).pathExtension.lowercased()
let type: String?
switch release.mediaType {
case "cartridge": type = ext == "ccc" ? "cartridge" : nil
case "cassette": type = ["cas", "wav"].contains(ext) ? "cassette" : nil
case "disk", "sdc": type = Self.supportsDisk(ext, profile: profile) ? "disk" : nil
default: type = nil
}
return type.map { Candidate(path: path, mediaType: $0) }
}.sorted { $0.path.localizedStandardCompare($1.path) == .orderedAscending }
let choice: Candidate
if let selectedMember {
guard let match = candidates.first(where: { $0.path == selectedMember }) else { throw Failure.invalidRecipe("Choose a compatible file from this installation.") }
choice = match
} else if candidates.count == 1 { choice = candidates[0] }
else if !candidates.isEmpty { throw Failure.needsSelection(candidates) }
else { throw Failure.unsupported("No supported startup media has been identified for this edition. Open its installed files and use the loading notes to configure it manually.") }
selected = [(choice.mediaType == "cartridge" ? "cartridge" : choice.mediaType == "cassette" ? "media" : "disk0", choice.path)]
} else if selectedMember != nil { throw Failure.invalidRecipe("This edition already identifies its startup media.") }
guard selected.count <= 4, Set(selected.map(\.target)).count == selected.count else { throw Failure.invalidRecipe("Conflicting startup media assignments.") }
var floppies: [Int: URL] = [:]
var cassette: URL?, cartridge: URL?
var selectedSDC: [Int: URL] = [:]
for member in selected {
let url = try file(member.path, root: root)
let ext = url.pathExtension.lowercased()
switch member.target {
case "cartridge":
guard profile == .romCartridge, ["ccc", "rom"].contains(ext) else { throw Failure.invalidRecipe("The selected file is not a supported ROM cartridge.") }
cartridge = url
case "media":
guard profile == .diskBasic, ["cas", "wav"].contains(ext) else { throw Failure.invalidRecipe("The selected file is not a supported cassette.") }
cassette = url
case "disk0", "disk1", "disk2", "disk3":
guard Self.supportsDisk(ext, profile: profile),
let drive = Int(member.target.suffix(1)) else { throw Failure.invalidRecipe("Unsupported disk assignment.") }
if profile == .cocoSDC {
guard drive < 2 else { throw Failure.invalidRecipe("CoCo SDC has two drives.") }
selectedSDC[drive] = url
} else { floppies[drive] = url }
default: throw Failure.invalidRecipe("Unknown media target: " + member.target)
}
}
if profile == .romCartridge && cartridge == nil { throw Failure.invalidRecipe("A startup cartridge is required.") }
var sdcFolder: URL?, sdcNames: [Int: String] = [:]
if profile == .cocoSDC {
guard let first = selectedSDC.keys.sorted().first.flatMap({ selectedSDC[$0] }) else { throw Failure.invalidRecipe("Select an SDC startup image.") }
let folder: URL
if let relative = config["sd_working_directory"].string {
folder = try directory(relative, root: root)
} else { folder = first.deletingLastPathComponent() }
try inspectSDCTree(folder)
for (drive, url) in selectedSDC {
guard url.path.hasPrefix(folder.path + "/") else { throw Failure.invalidRecipe("The selected SDC image is outside its SD card folder.") }
let name = String(url.path.dropFirst(folder.path.count + 1))
guard name.utf8.count <= 220, name.unicodeScalars.allSatisfy({ (32...126).contains($0.value) }), !name.contains("\"") else {
throw Failure.unsupported("This SD card image needs manual selection because its name cannot be entered safely in SDC-DOS.")
}
sdcNames[drive] = name
}
sdcFolder = folder
}
let decoded = members.isEmpty ? nil : decodeCommands(release.setup.command)
let canStart = cartridge != nil || (decoded?.contains(where: startsSoftware) == true)
var commands = canStart ? (decoded ?? []) : []
// Mounting an image is separate from executing its program. Manual SDC
// editions still get their chosen image mounted before guidance appears.
if sdcFolder != nil {
commands = sdcNames.keys.sorted().map { "DRIVE \($0),\"\(sdcNames[$0]!)\"" } + commands
}
var instructions = release.setup.instructions.trimmingCharacters(in: .whitespacesAndNewlines)
if instructions.isEmpty { instructions = "The selected media is mounted. Follow its manual or directory listing to choose a program; no startup command has been established." }
if !canStart, let command = release.setup.command, !command.isEmpty {
instructions += "\n\nThe catalog’s loading sequence needs manual entry. Review it before typing: " + command.replacingOccurrences(of: "\\r", with: " → ")
}
return Self(workingDirectory: root, canonicalWorkingDirectory: root.resolvingSymlinksInPath(), releaseID: release.id, title: release.metadata["title"].string ?? release.name,
profile: profile, use6309: cpu == "6309", ramKiB: ram, ramIndex: ramIndex,
videoOutput: video, controllerSlot: slot, cartridgeDevice: cartridgeDevice, floppyURLs: floppies, cassetteURL: cassette,
cartridgeURL: cartridge, sdcFolderURL: sdcFolder, sdcInitialImages: sdcNames,
commands: commands, manualInstructions: instructions,
compatibilityNotes: release.setup.compatibilityNotes + release.setup.configurationRequirements,
automaticallyStarts: canStart, controls: release.setup.controls,
curatedStartup: release.ownedGame.flatMap { $0.firstPlayColdDOS ? $0 : nil })
}
private static func recommendedCartridgeDevice(_ config: LibraryJSON, profile: Profile) throws -> CartridgeDevice {
let value = config["cartridge_device"]
guard value != .null else { return .rom }
guard let name = value.string, let device = CartridgeDevice(rawValue: name),
profile == .romCartridge else {
throw Failure.unsupported("This edition specifies a cartridge device that automatic setup does not support. Its installed files and loading notes remain available for manual configuration.")
}
return device
}
/// Recheck after a preview/dialog; a user or another process may have changed files.
func validateMedia() throws {
try Self.checkDirectory(workingDirectory)
guard workingDirectory.resolvingSymlinksInPath() == canonicalWorkingDirectory else { throw Failure.unsafeMedia("The working folder changed after setup was prepared.") }
if let curatedStartup {
// Verify the published original; working disks may contain saves/scores.
let original = try Self.file("Original/Files/" + curatedStartup.diskPath, root: workingDirectory.deletingLastPathComponent())
let bytes = try Data(contentsOf: original, options: .mappedIfSafe)
guard bytes.count == curatedStartup.diskByteSize,
SHA256.hash(data: bytes).map({ String(format: "%02x", $0) }).joined() == curatedStartup.diskSHA256 else {
throw Failure.invalidRecipe("The original game disk no longer matches its verified startup recipe. Your working files are kept.")
}
}
for url in Array(floppyURLs.values) + [cassetteURL, cartridgeURL].compactMap({ $0 }) {
guard url.path.hasPrefix(workingDirectory.path + "/") else { throw Failure.unsafeMedia(url.lastPathComponent) }
_ = try Self.file(String(url.path.dropFirst(workingDirectory.path.count + 1)), root: workingDirectory)
}
if let sdcFolderURL {
guard sdcFolderURL == workingDirectory || sdcFolderURL.path.hasPrefix(workingDirectory.path + "/") else { throw Failure.unsafeMedia("The SD card folder left its installation.") }
if sdcFolderURL != workingDirectory {
_ = try Self.directory(String(sdcFolderURL.path.dropFirst(workingDirectory.path.count + 1)), root: workingDirectory)
}
try Self.inspectSDCTree(sdcFolderURL)
for name in sdcInitialImages.values { _ = try Self.file(name, root: sdcFolderURL) }
}
}
private static func validRelative(_ path: String) -> Bool {
!path.isEmpty && path.utf8.count <= 4096 && !path.hasPrefix("/") && !path.contains("\\") && !path.contains(":")
&& !path.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains)
&& path.split(separator: "/", omittingEmptySubsequences: false).allSatisfy { !$0.isEmpty && $0 != "." && $0 != ".." }
}
private static func checkDirectory(_ url: URL) throws {
guard let values = try? url.resourceValues(forKeys: [.isDirectoryKey, .isSymbolicLinkKey]), values.isDirectory == true,
values.isSymbolicLink != true else { throw Failure.unsafeMedia(url.lastPathComponent) }
}
private static func checked(_ relative: String, root: URL, isDirectory: Bool) throws -> URL {
guard validRelative(relative) else { throw Failure.unsafeMedia(relative) }
var url = root
let components = relative.split(separator: "/")
for (index, component) in components.enumerated() {
url.appendPathComponent(String(component))
guard let values = try? url.resourceValues(forKeys: [.isSymbolicLinkKey, .isDirectoryKey, .isRegularFileKey]),
values.isSymbolicLink != true else { throw Failure.missingMedia(relative) }
if index < components.count - 1 || isDirectory {
guard values.isDirectory == true else { throw Failure.unsafeMedia(relative) }
} else { guard values.isRegularFile == true else { throw Failure.unsafeMedia(relative) } }
}
guard url.resolvingSymlinksInPath().path.hasPrefix(root.resolvingSymlinksInPath().path + "/") else { throw Failure.unsafeMedia(relative) }
return url
}
private static func file(_ relative: String, root: URL) throws -> URL { try checked(relative, root: root, isDirectory: false) }
private static func directory(_ relative: String, root: URL) throws -> URL { try checked(relative, root: root, isDirectory: true) }
private static func inspectSDCTree(_ root: URL) throws {
try checkDirectory(root)
let keys: [URLResourceKey] = [.isSymbolicLinkKey, .isDirectoryKey, .isRegularFileKey]
var scanFailed = false
guard let entries = FileManager.default.enumerator(at: root, includingPropertiesForKeys: keys,
errorHandler: { _, _ in scanFailed = true; return false }) else { throw Failure.unsafeMedia("The SD card folder cannot be read.") }
var count = 0
for case let url as URL in entries {
count += 1
guard count <= 20_000 else { throw Failure.unsafeMedia("The SD card folder has too many entries.") }
let value = try url.resourceValues(forKeys: Set(keys))
guard value.isSymbolicLink != true, value.isDirectory == true || value.isRegularFile == true else { throw Failure.unsafeMedia("The SD card folder contains a link or special file.") }
}
guard !scanFailed else { throw Failure.unsafeMedia("Part of the SD card folder cannot be read.") }
}
/// Recognize the bounded BASIC loading vocabulary used by reviewed recipes.
/// Unknown guest programs remain manual; nothing is passed to a host shell.
static func decodeCommands(_ input: String?) -> [String]? {
guard let input, input.utf8.count <= 4096 else { return nil }
let normalized = input.replacingOccurrences(of: "\\r", with: "\r").replacingOccurrences(of: "\r\n", with: "\n").replacingOccurrences(of: "\r", with: "\n")
guard normalized.unicodeScalars.allSatisfy({ $0.value == 10 || (32...126).contains($0.value) }) else { return nil }
let lines = normalized.split(separator: "\n", omittingEmptySubsequences: true).map { String($0).trimmingCharacters(in: .whitespaces) }
guard !lines.isEmpty, lines.count <= 16, lines.allSatisfy({ !$0.isEmpty && $0.utf8.count <= 255 && validLine($0) }) else { return nil }
// Once software runs, later keystrokes could reach that program instead
// of BASIC. Same-line loader chains remain one guest BASIC statement.
guard !lines.dropLast().contains(where: startsSoftware) else { return nil }
return lines
}
private static func statements(_ line: String) -> [String]? {
var result: [String] = [], current = "", quoted = false
for character in line {
if character == "\"" { quoted.toggle() }
if character == ":" && !quoted { result.append(current.trimmingCharacters(in: .whitespaces)); current = "" }
else { current.append(character) }
}
guard !quoted else { return nil }
result.append(current.trimmingCharacters(in: .whitespaces)); return result
}
private static func validLine(_ line: String) -> Bool {
guard let parts = statements(line) else { return false }
let number = "(?:[0-9]+|&H[0-9A-F]+)"
let filename = "\\\"[^\\\"\\\\]{1,64}\\\""
let patterns = ["(?:CLOADM?|RUN)(?: *" + filename + ")?", "LOADM *" + filename,
"LOAD *" + filename + " *, *R", "LOAD +CHR\\$\\(42\\) *, *R",
"EXEC(?: *" + number + ")?", "DOS(?: +[0-9]+)?", "DIR(?: +[0-3])?",
"PCLEAR *[0-9]+", "CLEAR *" + number + "(?: *, *" + number + ")?",
"POKE *" + number + " *, *" + number, "NEW"]
return parts.allSatisfy { part in patterns.contains { part.range(of: "^(?:" + $0 + ")$", options: [.regularExpression, .caseInsensitive]) != nil } }
}
private static func startsSoftware(_ line: String) -> Bool {
guard let parts = statements(line.uppercased()) else { return false }
return parts.contains { $0.hasPrefix("RUN") || $0.hasPrefix("EXEC") || $0.hasPrefix("DOS") || ($0.hasPrefix("LOAD") && $0.range(of: ", *R$", options: .regularExpression) != nil) }
}
}