Sync VCC Plus 3.7.1 build 67 source
Refresh reviewed MCP output export, four-drive owned playtests, bounded BASIC readiness, and pinned CMOC 0.1.101 source/patches. Preserve independent source-edition identity, empty libraries, notices and privacy boundaries. Validated 74 export/privacy checks, pinned dependency sources, and an independent unsigned universal Release build. A subsequent documentation-only correction removes an excluded qualification link; all build inputs remain identical.
This commit is contained in:
1 parent
4abc194001
commit
5534005799
54 files changed
+2950
-435
No files matched your search
@@ -59,15 +59,23 @@ struct MCPPlaytestDiskStore: Sendable {
|
||||
let originArtifactDiskSHA256: String?
|
||||
let mediaKey: String?
|
||||
let mediaBaseSHA256: String?
|
||||
let writeProtected: Bool?
|
||||
|
||||
init(projectKey: String?, artifactID: String?, artifactDiskSHA256: String?, parentDiskID: String? = nil,
|
||||
origin: String = "verified_artifact", originArtifactID: String? = nil, originArtifactDiskSHA256: String? = nil,
|
||||
mediaKey: String? = nil, mediaBaseSHA256: String? = nil) {
|
||||
mediaKey: String? = nil, mediaBaseSHA256: String? = nil, writeProtected: Bool? = nil) {
|
||||
self.projectKey = projectKey; self.artifactID = artifactID; self.artifactDiskSHA256 = artifactDiskSHA256
|
||||
self.parentDiskID = parentDiskID; self.origin = origin
|
||||
self.originArtifactID = originArtifactID ?? (origin == "verified_artifact" ? artifactID : nil)
|
||||
self.originArtifactDiskSHA256 = originArtifactDiskSHA256 ?? (origin == "verified_artifact" ? artifactDiskSHA256 : nil)
|
||||
self.mediaKey = mediaKey; self.mediaBaseSHA256 = mediaBaseSHA256
|
||||
self.mediaKey = mediaKey; self.mediaBaseSHA256 = mediaBaseSHA256; self.writeProtected = writeProtected
|
||||
}
|
||||
|
||||
func protecting(_ enabled: Bool) -> Self {
|
||||
Self(projectKey: projectKey, artifactID: artifactID, artifactDiskSHA256: artifactDiskSHA256,
|
||||
parentDiskID: parentDiskID, origin: origin, originArtifactID: originArtifactID,
|
||||
originArtifactDiskSHA256: originArtifactDiskSHA256, mediaKey: mediaKey,
|
||||
mediaBaseSHA256: mediaBaseSHA256, writeProtected: enabled)
|
||||
}
|
||||
|
||||
var publicFields: [String: Any] {
|
||||
@@ -76,6 +84,8 @@ struct MCPPlaytestDiskStore: Sendable {
|
||||
"origin_artifact_id": originArtifactID as Any? ?? NSNull(),
|
||||
"origin_artifact_disk_sha256": originArtifactDiskSHA256 as Any? ?? NSNull()]
|
||||
if let parentDiskID { fields["parent_disk_id"] = parentDiskID }
|
||||
fields["write_protected"] = writeProtected ?? false
|
||||
fields["write_protection_recorded"] = writeProtected != nil
|
||||
fields["media_key"] = mediaKey ?? "primary"
|
||||
fields["media_base_sha256"] = (mediaBaseSHA256 ?? artifactDiskSHA256) as Any? ?? NSNull()
|
||||
return fields
|
||||
@@ -485,11 +495,19 @@ final class MCPPlaytest {
|
||||
let source: MCPPlaytestMedium
|
||||
var data: Data
|
||||
var dirty = false
|
||||
var writeProtected = false
|
||||
var retained: MCPPlaytestDiskStore.Record?
|
||||
var pendingRecordID: String?
|
||||
}
|
||||
private var media: [String: MediumState]?
|
||||
private var mediaOrder: [String] = []
|
||||
private let multiDrive: Bool
|
||||
private var mountedMediaIDs: [String?] = Array(repeating: nil, count: 4)
|
||||
private var pendingMediaDrive: Int?
|
||||
private var lastSafeMediaExports: [Int: [String: Any]] = [:]
|
||||
private var frozenDriveExports = Set<Int>()
|
||||
private var mediaFreezeAcknowledged = false
|
||||
private var mediaStopDrained = false
|
||||
private var mountedMediaID: String?
|
||||
private var mediaExchangeTask: Task<[String: Any], Error>?
|
||||
private var mediaFailures: [String: (Data, String)] = [:]
|
||||
@@ -499,16 +517,17 @@ final class MCPPlaytest {
|
||||
|
||||
private init(worker: Worker, projectID: String, revision: Int, artifactID: String, retentionDirectory: URL,
|
||||
diskProvenance: MCPPlaytestDiskStore.Provenance, resumedDiskID: String?, runID: String,
|
||||
processor: MCPPlaytestProcessor, media: [MCPPlaytestMedium]?,
|
||||
processor: MCPPlaytestProcessor, media: [MCPPlaytestMedium]?, multiDrive: Bool,
|
||||
videoArtifactWillVerify: (@Sendable (URL) throws -> Void)?) {
|
||||
self.runID = runID
|
||||
self.worker = worker; self.projectID = projectID; self.revision = revision; self.artifactID = artifactID
|
||||
self.retentionDirectory = retentionDirectory; self.diskProvenance = diskProvenance; self.resumedDiskID = resumedDiskID
|
||||
self.processor = processor
|
||||
self.processor = processor; self.multiDrive = multiDrive
|
||||
self.videoArtifactWillVerify = videoArtifactWillVerify
|
||||
if let media {
|
||||
self.media = Dictionary(uniqueKeysWithValues: media.map { ($0.id, MediumState(source: $0, data: $0.data)) })
|
||||
self.media = Dictionary(uniqueKeysWithValues: media.map { ($0.id, MediumState(source: $0, data: $0.data, writeProtected: $0.provenance.writeProtected ?? false)) })
|
||||
self.mediaOrder = media.map(\.id); self.mountedMediaID = media.first?.id
|
||||
self.mountedMediaIDs[0] = media.first?.id
|
||||
}
|
||||
}
|
||||
|
||||
@@ -517,7 +536,7 @@ final class MCPPlaytest {
|
||||
modules: [[String: Any]] = [], stopAt: UInt16? = nil, stopModule: String? = nil, flatGuards: [[String: Any]] = [], cpu: String = "6809", helperURL: URL? = nil, retentionDirectory: URL? = nil,
|
||||
diskProvenance: MCPPlaytestDiskStore.Provenance? = nil, resumedDiskID: String? = nil,
|
||||
graphicsBuffers: [[String: Any]] = [], runID: String = UUID().uuidString,
|
||||
media: [MCPPlaytestMedium]? = nil,
|
||||
media: [MCPPlaytestMedium]? = nil, multiDrive: Bool = false,
|
||||
videoArtifactWillVerify: (@Sendable (URL) throws -> Void)? = nil) async throws -> MCPPlaytest {
|
||||
guard let reservedID = UUID(uuidString: runID) else { throw failure("invalid_playtest_run_id") }
|
||||
guard systemROM.count == 32768, diskROM.count == 8192, !disk.isEmpty, disk.count <= 512 * 1024,
|
||||
@@ -561,12 +580,18 @@ final class MCPPlaytest {
|
||||
let test = MCPPlaytest(worker: worker, projectID: projectID, revision: revision, artifactID: artifactID,
|
||||
retentionDirectory: retentionDirectory ?? AppIdentity.supportDirectory.appendingPathComponent("Development Runs/Assistant Playtests"),
|
||||
diskProvenance: provenance, resumedDiskID: resumedDiskID.map { UUID(uuidString: $0)!.uuidString }, runID: reservedID.uuidString,
|
||||
processor: cpu == "6309" ? .hd6309 : .mc6809, media: media, videoArtifactWillVerify: videoArtifactWillVerify)
|
||||
processor: cpu == "6309" ? .hd6309 : .mc6809, media: media, multiDrive: multiDrive, videoArtifactWillVerify: videoArtifactWillVerify)
|
||||
var setup: [String: Any] = ["op": "init", "system_rom": systemROM.base64EncodedString(),
|
||||
"disk_rom": diskROM.base64EncodedString(), "disk": disk.base64EncodedString(),
|
||||
"boot_keys": paste.chords.map { NSNumber(value: $0) }, "modules": modules, "cpu": cpu,
|
||||
"graphics_buffers": graphicsBuffers, "flat_guards": flatGuards]
|
||||
if let media { setup["media_id"] = media[0].id }
|
||||
if let protection = provenance.writeProtected { setup["write_protected"] = protection }
|
||||
if multiDrive {
|
||||
guard media != nil else { await test.invalidate().value; throw failure("invalid_playtest_media") }
|
||||
setup["multi_drive"] = true
|
||||
setup["write_protected"] = media?.first?.provenance.writeProtected ?? false
|
||||
}
|
||||
if let stopAt {
|
||||
guard (modules.isEmpty && !flatGuards.isEmpty && stopModule == nil) ||
|
||||
(!modules.isEmpty && flatGuards.isEmpty && stopModule != nil) else {
|
||||
@@ -665,7 +690,237 @@ final class MCPPlaytest {
|
||||
}
|
||||
}
|
||||
|
||||
private func driveRow(_ status: [String: Any], drive: Int) throws -> [String: Any] {
|
||||
guard let rows = status["drives"] as? [[String: Any]], rows.count == 4,
|
||||
rows.enumerated().allSatisfy({ index, row in
|
||||
guard let number = row["drive"] as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return false }
|
||||
return number.doubleValue == Double(index)
|
||||
}) else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
return rows[drive]
|
||||
}
|
||||
|
||||
private func multiMediaFields(status: [String: Any]) -> [String: Any] {
|
||||
var fields = status
|
||||
let workerRows = status["drives"] as? [[String: Any]] ?? []
|
||||
fields["media_contract_version"] = 2
|
||||
fields["drive"] = "FD0" // Existing top-level compatibility field.
|
||||
fields["drives"] = (0..<4).map { drive -> [String: Any] in
|
||||
var row = workerRows.count == 4 ? workerRows[drive] : ["drive": drive, "label": "FD\(drive)", "unavailable": true]
|
||||
if let id = row["media_id"] as? String, let item = media?[id] {
|
||||
row["base_sha256"] = item.source.baseSHA256
|
||||
row["media_sha256"] = row["disk_sha256"]
|
||||
row["media_key"] = item.source.key
|
||||
row["name"] = item.source.name
|
||||
row["provenance"] = item.source.provenance.protecting(row["write_protected"] as? Bool ?? item.writeProtected).publicFields
|
||||
row["modified_from_artifact"] = row["disk_sha256"] as? String != item.source.baseSHA256
|
||||
let retained = item.retained
|
||||
row["retained"] = retained?.diskSHA256 == row["disk_sha256"] as? String && retained?.provenance.writeProtected == row["write_protected"] as? Bool
|
||||
if let retained { row["retained_disk"] = retained.publicFields }
|
||||
}
|
||||
return row
|
||||
}
|
||||
fields["media"] = mediaOrder.compactMap { id -> [String: Any]? in
|
||||
guard let item = media?[id] else { return nil }
|
||||
let mounted = workerRows.first { $0["media_id"] as? String == id && $0["disk_present"] as? Bool == true }
|
||||
let hash = mounted?["disk_sha256"] as? String ?? CMOCProject.sha256(item.data)
|
||||
let protection = mounted?["write_protected"] as? Bool ?? item.writeProtected
|
||||
var row: [String: Any] = ["media_id": id, "name": item.source.name, "media_key": item.source.key,
|
||||
"base_sha256": item.source.baseSHA256, "media_sha256": hash, "byte_count": item.data.count,
|
||||
"inserted": mounted != nil, "drive": mounted?["drive"] as Any? ?? NSNull(),
|
||||
"dirty": mounted?["disk_dirty"] as? Bool ?? item.dirty, "write_protected": protection,
|
||||
"provenance": item.source.provenance.protecting(protection).publicFields,
|
||||
"modified_from_artifact": hash != item.source.baseSHA256,
|
||||
"retained": item.retained?.diskSHA256 == hash && item.retained?.provenance.writeProtected == protection]
|
||||
if let retained = item.retained { row["retained_disk"] = retained.publicFields }
|
||||
if let parent = item.source.provenance.parentDiskID { row["resumed_from_disk_id"] = parent }
|
||||
if status["media_selection_uncertain"] as? Bool == true { row["placement_uncertain"] = true }
|
||||
return row
|
||||
}
|
||||
return fields
|
||||
}
|
||||
|
||||
/// One bounded worker message contains one drive's bytes plus a coherent
|
||||
/// four-drive metadata observation. Never concatenate four disk payloads.
|
||||
private func receiveMultiMediaExport(_ status: [String: Any], drive: Int) throws {
|
||||
let row = try driveRow(status, drive: drive)
|
||||
guard let exported = status["exported_drive"] as? [String: Any], NSDictionary(dictionary: exported).isEqual(to: row),
|
||||
let present = row["disk_present"] as? Bool, let hash = row["disk_sha256"] as? String,
|
||||
let protection = row["write_protected"] as? Bool else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
let id = row["media_id"] as? String
|
||||
let pendingMatches = mediaCommitPending && pendingMediaDrive == drive && id == pendingMediaSelection
|
||||
guard id == mountedMediaIDs[drive] || pendingMatches else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
if !present {
|
||||
guard id == nil, hash.isEmpty, status["disk_base64"] == nil,
|
||||
(row["byte_count"] as? NSNumber)?.intValue == 0 else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
mountedMediaIDs[drive] = nil
|
||||
} else {
|
||||
guard let id, var item = media?[id], let encoded = status["disk_base64"] as? String,
|
||||
let bytes = Data(base64Encoded: encoded), !bytes.isEmpty, bytes.count <= 512 * 1024,
|
||||
bytes.count == (row["byte_count"] as? NSNumber)?.intValue,
|
||||
CMOCProject.sha256(bytes) == hash else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
if item.data != bytes || item.writeProtected != protection { item.pendingRecordID = nil }
|
||||
item.data = bytes; item.dirty = row["disk_dirty"] as? Bool ?? false; item.writeProtected = protection
|
||||
media?[id] = item; mountedMediaIDs[drive] = id
|
||||
}
|
||||
mountedMediaID = mountedMediaIDs[0]
|
||||
}
|
||||
|
||||
private func exchangeMultiMedia(_ selected: String?, expectedSHA: String?, drive: Int,
|
||||
writeProtected: Bool?, isCurrent: (() -> Bool)?) async throws -> [String: Any] {
|
||||
guard valid, isCurrent?() != false else { throw Self.failure("stale_run") }
|
||||
if let selected {
|
||||
guard media?[selected] != nil else { throw Self.failure("invalid_playtest_media_selection") }
|
||||
guard !mountedMediaIDs.enumerated().contains(where: { $0.offset != drive && $0.element == selected }) else {
|
||||
throw Self.failure("playtest_media_already_inserted")
|
||||
}
|
||||
}
|
||||
var frozen: [Int: [String: Any]] = [:]
|
||||
for index in 0..<4 {
|
||||
let snapshot = try await worker.request(["op": "export_media", "drive": index])
|
||||
try receiveMultiMediaExport(snapshot, drive: index)
|
||||
if let first = frozen[0] {
|
||||
for key in ["field_clock", "cycles", "generation", "boot", "pc"] {
|
||||
guard let a = first[key] as? NSNumber, let b = snapshot[key] as? NSNumber, a == b else {
|
||||
throw WorkerTransportFailure(reason: "playtest_media_advanced_guest")
|
||||
}
|
||||
}
|
||||
}
|
||||
frozen[index] = snapshot
|
||||
}
|
||||
guard let before = frozen[drive] else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
let oldRow = try driveRow(before, drive: drive), expectedOldID = mountedMediaIDs[drive]
|
||||
guard valid, isCurrent?() != false, let generation = oldRow["media_generation"] as? NSNumber,
|
||||
let oldHash = oldRow["disk_sha256"] as? String else { throw Self.failure("stale_playtest_media") }
|
||||
if let selected, let item = media?[selected], expectedSHA != CMOCProject.sha256(item.data) {
|
||||
throw Self.failure("playtest_media_hash_mismatch")
|
||||
}
|
||||
var old: [String: Any] = ["media_id": expectedOldID as Any? ?? NSNull(), "media_sha256": oldHash,
|
||||
"drive": drive, "dirty": oldRow["disk_dirty"] as? Bool ?? false, "retained": false,
|
||||
"write_protected": oldRow["write_protected"] as? Bool ?? false]
|
||||
if let expectedOldID {
|
||||
let retained = try await retainMedium(expectedOldID)
|
||||
old["retained"] = true; old["retained_disk"] = retained.publicFields
|
||||
}
|
||||
guard valid, isCurrent?() != false, mountedMediaIDs[drive] == expectedOldID else { throw Self.failure("stale_run") }
|
||||
var request: [String: Any] = ["op": "exchange_media", "drive": drive,
|
||||
"expected_media_generation": generation, "expected_disk_sha256": oldHash]
|
||||
if let selected, let item = media?[selected] {
|
||||
request["media_id"] = selected; request["disk_base64"] = item.data.base64EncodedString()
|
||||
request["write_protected"] = writeProtected ?? item.writeProtected
|
||||
}
|
||||
lastSafeMediaExports = frozen
|
||||
mediaCommitPending = true; pendingMediaDrive = drive; pendingMediaSelection = selected
|
||||
let after: [String: Any]
|
||||
do { after = try await worker.request(request) }
|
||||
catch let error as WorkerRejection { mediaCommitPending = false; pendingMediaDrive = nil; pendingMediaSelection = nil; throw error }
|
||||
// Acknowledged commit is authoritative even if the grant expires now.
|
||||
mountedMediaIDs[drive] = selected; mountedMediaID = mountedMediaIDs[0]
|
||||
mediaCommitPending = false; pendingMediaDrive = nil; pendingMediaSelection = nil
|
||||
let next = try driveRow(after, drive: drive)
|
||||
let selectedSHA = selected.flatMap { media?[$0] }.map { CMOCProject.sha256($0.data) } ?? ""
|
||||
guard next["disk_sha256"] as? String == selectedSHA, next["media_id"] as? String == selected,
|
||||
next["disk_present"] as? Bool == (selected != nil),
|
||||
(next["media_generation"] as? NSNumber)?.intValue == generation.intValue + 1,
|
||||
after["previous_disk_sha256"] as? String == oldHash else { throw WorkerTransportFailure(reason: "invalid_playtest_media_reply") }
|
||||
if let selected, var item = media?[selected], let effective = next["write_protected"] as? Bool {
|
||||
if effective != item.writeProtected { item.pendingRecordID = nil }
|
||||
item.writeProtected = effective; media?[selected] = item
|
||||
}
|
||||
for index in 0..<4 where index != drive {
|
||||
guard NSDictionary(dictionary: try driveRow(before, drive: index)).isEqual(to: try driveRow(after, drive: index)) else {
|
||||
throw WorkerTransportFailure(reason: "playtest_unrelated_drive_changed")
|
||||
}
|
||||
}
|
||||
for key in ["field_clock", "cycles", "generation", "boot", "pc"] {
|
||||
guard let a = before[key] as? NSNumber, let b = after[key] as? NSNumber, a == b else { throw WorkerTransportFailure(reason: "playtest_media_advanced_guest") }
|
||||
}
|
||||
var result = mediaFields(status: after)
|
||||
result["target_drive"] = drive; result["previous_media"] = old
|
||||
result["exchange"] = selected == nil ? "ejected" : "inserted"
|
||||
result["guest_advanced"] = false; result["guest_reset"] = false
|
||||
return result
|
||||
}
|
||||
|
||||
private func performMultiMediaPersistence() async throws -> [String: Any] {
|
||||
if let pending = mediaExchangeTask { _ = await pending.result }
|
||||
if finished, let finalReceipt { return finalReceipt }
|
||||
if !mediaFreezeAcknowledged {
|
||||
do {
|
||||
var result = try await worker.request(["op": "stop"])
|
||||
guard result["media_frozen"] as? Bool == true else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
_ = try driveRow(result, drive: 0)
|
||||
mediaFreezeAcknowledged = true; exportedStatus = result
|
||||
guard let primary = mediaOrder.first, let bytes = media?[primary]?.data else { throw Self.failure("invalid_playtest_media") }
|
||||
exportedDisk = bytes // Retry marker, not a claim that all drives were drained.
|
||||
do { try await retainVideoMetadata(result) }
|
||||
catch { result["video_retention_error"] = "The video artifact could not be verified; disk retention continues."; exportedStatus = result }
|
||||
} catch let error as WorkerTransportFailure {
|
||||
// Only a fully observed paused four-drive export can recover a
|
||||
// lost exchange reply. It is never substituted after execution.
|
||||
guard lastSafeMediaExports.count == 4, let before = lastSafeMediaExports[0] else { throw error }
|
||||
var result = before
|
||||
result.removeValue(forKey: "disk_base64"); result.removeValue(forKey: "exported_drive")
|
||||
result["media_selection_uncertain"] = true
|
||||
result["uncertain_drives"] = pendingMediaDrive.map { [$0] } ?? Array(0..<4)
|
||||
if var rows = result["drives"] as? [[String: Any]] {
|
||||
for index in (pendingMediaDrive.map { [$0] } ?? Array(0..<4)) {
|
||||
rows[index]["media_id"] = NSNull(); rows[index]["disk_present"] = NSNull()
|
||||
rows[index]["inserted"] = NSNull(); rows[index]["selection_uncertain"] = true
|
||||
rows[index]["disk_sha256"] = NSNull(); rows[index]["media_generation"] = NSNull()
|
||||
mountedMediaIDs[index] = nil
|
||||
}
|
||||
result["drives"] = rows
|
||||
if pendingMediaDrive == nil || pendingMediaDrive == 0 {
|
||||
result["media_id"] = NSNull(); result["disk_present"] = NSNull(); result["disk_sha256"] = NSNull()
|
||||
}
|
||||
}
|
||||
mountedMediaID = mountedMediaIDs[0]
|
||||
exportedStatus = result; mediaFreezeAcknowledged = true; mediaStopDrained = true
|
||||
frozenDriveExports = Set(0..<4)
|
||||
exportedDisk = mediaOrder.first.flatMap { media?[$0]?.data }
|
||||
}
|
||||
}
|
||||
do {
|
||||
for drive in 0..<4 where !frozenDriveExports.contains(drive) {
|
||||
let result = try await worker.request(["op": "export_media", "drive": drive])
|
||||
try receiveMultiMediaExport(result, drive: drive)
|
||||
// Each reply must match the STOP observation, with no execution
|
||||
// or selection change while bounded exports are drained.
|
||||
guard let frozen = exportedStatus,
|
||||
NSDictionary(dictionary: try driveRow(frozen, drive: drive)).isEqual(to: try driveRow(result, drive: drive)) else {
|
||||
throw Self.failure("playtest_frozen_media_changed")
|
||||
}
|
||||
frozenDriveExports.insert(drive)
|
||||
}
|
||||
if !mediaStopDrained {
|
||||
do { _ = try await worker.request(["op": "finish_stop"]) }
|
||||
catch is WorkerTransportFailure { /* Every mounted disk was already drained and verified. */ }
|
||||
mediaStopDrained = true
|
||||
}
|
||||
var retained: [[String: Any]] = []
|
||||
for id in mediaOrder {
|
||||
let record = try await retainMedium(id)
|
||||
var fields = record.publicFields; fields["media_id"] = id; fields["name"] = media?[id]?.source.name
|
||||
retained.append(fields)
|
||||
}
|
||||
guard let primary = mediaOrder.first, let record = media?[primary]?.retained else { throw Self.failure("playtest_disk_export_failed") }
|
||||
retainedDiskRecord = record; retainedDiskURL = try MCPPlaytestDiskStore.diskURL(directory: retentionDirectory, id: record.id)
|
||||
var result = mediaFields(status: exportedStatus ?? [:])
|
||||
result["disk_retained"] = true; result["retained_disk_id"] = record.id
|
||||
result["retained_disk_sha256"] = record.diskSHA256; result["retained_disk"] = record.publicFields
|
||||
result["retained_media"] = retained; result["status"] = "stopped"
|
||||
finished = true; retentionError = nil; worker.close()
|
||||
let receipt = scoped(result); finalReceipt = receipt
|
||||
exportedDisk = nil; exportedStatus = nil; Self.pendingRetentions.removeValue(forKey: runID)
|
||||
return receipt
|
||||
} catch {
|
||||
retentionError = error.localizedDescription; Self.pendingRetentions[runID] = self
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
private func mediaFields(status: [String: Any]) -> [String: Any] {
|
||||
if multiDrive { return multiMediaFields(status: status) }
|
||||
var fields = status
|
||||
let actualID = status["media_id"] == nil ? mountedMediaID : status["media_id"] as? String
|
||||
let present = status["disk_present"] as? Bool ?? (mountedMediaID != nil)
|
||||
@@ -689,6 +944,7 @@ final class MCPPlaytest {
|
||||
/// Only called with a bounded, complete export from the app-owned helper.
|
||||
/// Keep these bytes even if the lease was revoked while the pipe was read.
|
||||
private func receiveMediaExport(_ status: [String: Any]) throws {
|
||||
if multiDrive { try receiveMultiMediaExport(status, drive: 0); return }
|
||||
guard media != nil, let present = status["disk_present"] as? Bool else { throw Self.failure("invalid_playtest_media_reply") }
|
||||
if !present {
|
||||
guard (mountedMediaID == nil || (mediaCommitPending && pendingMediaSelection == nil)),
|
||||
@@ -713,11 +969,22 @@ final class MCPPlaytest {
|
||||
private func retainMedium(_ id: String) async throws -> MCPPlaytestDiskStore.Record {
|
||||
guard var item = media?[id] else { throw Self.failure("invalid_playtest_media_selection") }
|
||||
let hash = CMOCProject.sha256(item.data)
|
||||
if let existing = item.retained, existing.diskSHA256 == hash { return existing }
|
||||
if let existing = item.retained, existing.diskSHA256 == hash,
|
||||
!multiDrive || existing.provenance.writeProtected == item.writeProtected {
|
||||
guard let projectKey = existing.provenance.projectKey,
|
||||
let artifactHash = existing.provenance.artifactDiskSHA256 else { throw Self.failure("invalid_playtest_disk_provenance") }
|
||||
let loaded = try await MCPPlaytestDiskStore.load(directory: retentionDirectory, id: existing.id,
|
||||
expectedSHA256: hash, projectKey: projectKey, artifactDiskSHA256: artifactHash,
|
||||
mediaKey: existing.provenance.mediaKey ?? "primary", mediaBaseSHA256: existing.provenance.mediaBaseSHA256)
|
||||
guard loaded.record.id == existing.id, loaded.record.runID == existing.runID,
|
||||
loaded.record.provenance == existing.provenance, loaded.record.diskSHA256 == existing.diskSHA256,
|
||||
loaded.record.byteCount == existing.byteCount, loaded.data == item.data else { throw Self.failure("retained_disk_changed") }
|
||||
return existing
|
||||
}
|
||||
let recordID = item.pendingRecordID ?? UUID().uuidString
|
||||
item.pendingRecordID = recordID; media?[id] = item
|
||||
let stored = try await MCPPlaytestDiskStore.save(directory: retentionDirectory, runID: runID,
|
||||
data: item.data, provenance: item.source.provenance, recordID: recordID)
|
||||
data: item.data, provenance: multiDrive ? item.source.provenance.protecting(item.writeProtected) : item.source.provenance, recordID: recordID)
|
||||
// The paused worker and serialized owner cannot change this medium
|
||||
// during the off-main-thread durable write.
|
||||
guard var current = media?[id], current.data == item.data else { throw Self.failure("playtest_media_changed") }
|
||||
@@ -725,7 +992,9 @@ final class MCPPlaytest {
|
||||
return stored
|
||||
}
|
||||
|
||||
private func exchangeMedia(_ selected: String?, expectedSHA: String?, isCurrent: (() -> Bool)?) async throws -> [String: Any] {
|
||||
private func exchangeMedia(_ selected: String?, expectedSHA: String?, isCurrent: (() -> Bool)?,
|
||||
drive: Int = 0, writeProtected: Bool? = nil) async throws -> [String: Any] {
|
||||
if multiDrive { return try await exchangeMultiMedia(selected, expectedSHA: expectedSHA, drive: drive, writeProtected: writeProtected, isCurrent: isCurrent) }
|
||||
guard valid, isCurrent?() != false else { throw Self.failure("stale_run") }
|
||||
let before = try await worker.request(["op": "export_media"])
|
||||
let expectedOldID = mountedMediaID
|
||||
@@ -751,6 +1020,7 @@ final class MCPPlaytest {
|
||||
"expected_disk_sha256": oldHash]
|
||||
if let selected, let item = media?[selected] {
|
||||
request["media_id"] = selected; request["disk_base64"] = item.data.base64EncodedString()
|
||||
if let protection = item.source.provenance.writeProtected { request["write_protected"] = protection }
|
||||
}
|
||||
lastSafeMediaExport = before
|
||||
mediaCommitPending = true; pendingMediaSelection = selected
|
||||
@@ -781,6 +1051,7 @@ final class MCPPlaytest {
|
||||
}
|
||||
|
||||
private func performMediaPersistence() async throws -> [String: Any] {
|
||||
if multiDrive { return try await performMultiMediaPersistence() }
|
||||
if let pending = mediaExchangeTask { _ = await pending.result }
|
||||
if finished, let finalReceipt { return finalReceipt }
|
||||
if exportedDisk == nil {
|
||||
@@ -835,6 +1106,8 @@ final class MCPPlaytest {
|
||||
/// The host rechecks project/revision/artifact identity before dispatching.
|
||||
/// Cached write receipts are still bound to this live lease, never replayed.
|
||||
func reply(_ tool: String, arguments: [String: Any], isCurrent: (() -> Bool)? = nil) async throws -> [String: Any] {
|
||||
var arguments = arguments
|
||||
if tool == "exchange_playtest_media", multiDrive, arguments["drive"] == nil { arguments["drive"] = 0 }
|
||||
guard valid, arguments["run_id"] as? String == runID else { throw Self.failure("stale_run") }
|
||||
guard !busy else { throw Self.failure("playtest_busy") }
|
||||
busy = true
|
||||
@@ -903,10 +1176,22 @@ final class MCPPlaytest {
|
||||
}
|
||||
if tool == "exchange_playtest_media" {
|
||||
guard media != nil, let action = arguments["action"] as? String,
|
||||
["insert", "eject"].contains(action),
|
||||
Set(arguments.keys) == (action == "insert" ? ["run_id", "request_id", "action", "media_id", "media_sha256"] : ["run_id", "request_id", "action"]) else {
|
||||
throw Self.failure("invalid_arguments")
|
||||
}
|
||||
["insert", "eject"].contains(action) else { throw Self.failure("invalid_arguments") }
|
||||
var required: Set<String> = action == "insert" ? ["run_id", "request_id", "action", "media_id", "media_sha256"] : ["run_id", "request_id", "action"]
|
||||
if multiDrive { required.insert("drive") }
|
||||
let optional: Set<String> = multiDrive && action == "insert" ? ["write_protected"] : []
|
||||
guard required.isSubset(of: Set(arguments.keys)), Set(arguments.keys).isSubset(of: required.union(optional)) else { throw Self.failure("invalid_arguments") }
|
||||
let drive: Int
|
||||
if multiDrive {
|
||||
guard let value = arguments["drive"] as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID(),
|
||||
value.doubleValue.isFinite, value.doubleValue == Double(value.intValue), (0...3).contains(value.intValue) else { throw Self.failure("invalid_arguments") }
|
||||
drive = value.intValue
|
||||
} else { drive = 0 }
|
||||
let protection: Bool?
|
||||
if let value = arguments["write_protected"] {
|
||||
guard let number = value as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw Self.failure("invalid_arguments") }
|
||||
protection = number.boolValue
|
||||
} else { protection = nil }
|
||||
let selected: String?
|
||||
if action == "insert" {
|
||||
guard let id = arguments["media_id"] as? String, media?[id] != nil,
|
||||
@@ -918,7 +1203,7 @@ final class MCPPlaytest {
|
||||
} else { selected = nil }
|
||||
mutationRequestsAccepted += 1
|
||||
accepted[requestID] = (signature, scoped(["request_id": requestID, "status": "interrupted"]))
|
||||
let exchange = Task { try await self.exchangeMedia(selected, expectedSHA: arguments["media_sha256"] as? String, isCurrent: isCurrent) }
|
||||
let exchange = Task { try await self.exchangeMedia(selected, expectedSHA: arguments["media_sha256"] as? String, isCurrent: isCurrent, drive: drive, writeProtected: protection) }
|
||||
mediaExchangeTask = exchange
|
||||
defer { mediaExchangeTask = nil }
|
||||
var result: [String: Any]
|
||||
@@ -1045,7 +1330,7 @@ final class MCPPlaytest {
|
||||
}
|
||||
}
|
||||
do {
|
||||
lastSafeMediaExport = nil
|
||||
lastSafeMediaExport = nil; lastSafeMediaExports.removeAll()
|
||||
var result = try await worker.request(request)
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
try await retainVideoMetadata(result)
|
||||
@@ -1089,7 +1374,7 @@ final class MCPPlaytest {
|
||||
guard !busy else { throw Self.failure("playtest_busy") }
|
||||
busy = true
|
||||
defer { busy = false }
|
||||
if let operation = request["op"] as? String, ["continue", "step", "stop_at"].contains(operation) { lastSafeMediaExport = nil }
|
||||
if let operation = request["op"] as? String, ["continue", "step", "stop_at"].contains(operation) { lastSafeMediaExport = nil; lastSafeMediaExports.removeAll() }
|
||||
let result = try await worker.request(request)
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
try await retainVideoMetadata(result)
|
||||
@@ -1097,7 +1382,7 @@ final class MCPPlaytest {
|
||||
}
|
||||
|
||||
private func scoped(_ result: [String: Any]) -> [String: Any] {
|
||||
var result = result
|
||||
var result = multiDrive && media != nil ? mediaFields(status: result) : result
|
||||
result["run_id"] = runID; result["project_id"] = projectID
|
||||
result["revision"] = revision; result["artifact_id"] = artifactID
|
||||
result["requested_processor"] = processor.rawValue
|
||||
@@ -1122,7 +1407,8 @@ final class MCPPlaytest {
|
||||
result["boot_disk_provenance"] = diskProvenance.publicFields
|
||||
if let id = mountedMediaID, let current = media?[id] {
|
||||
result["disk_origin"] = current.source.provenance.origin
|
||||
result["disk_provenance"] = current.source.provenance.publicFields
|
||||
let currentProtection = (result["drives"] as? [[String: Any]])?.first?["write_protected"] as? Bool ?? current.writeProtected
|
||||
result["disk_provenance"] = multiDrive ? current.source.provenance.protecting(currentProtection).publicFields : current.source.provenance.publicFields
|
||||
} else {
|
||||
result["disk_origin"] = NSNull(); result["disk_provenance"] = NSNull()
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user