Sync source edition with VCC Plus 3.7.0 build 63
This commit is contained in:
1 parent
c652a5276d
commit
b2ecec4d87
86 files changed
+10519
-472
No files matched your search
@@ -366,6 +366,10 @@ final class MCPPlaytest {
|
||||
static let audioFieldLimit = 120
|
||||
static let audioCaptureLimit = 16
|
||||
static let audioByteLimit = 4 * 1024 * 1024
|
||||
static let videoFieldLimit = 3600
|
||||
static let videoClipLimit = 4
|
||||
static let videoByteLimit = 64 * 1024 * 1024
|
||||
static let videoRetainedByteLimit = 256 * 1024 * 1024
|
||||
private static let maximumAudioClipBytes = 44 + 131_072 * 4
|
||||
let runID: String
|
||||
let projectID: String
|
||||
@@ -394,6 +398,88 @@ final class MCPPlaytest {
|
||||
private var audioCapturesAccepted = 0
|
||||
private var audioBytesRetained = 0
|
||||
private var stopRequestID: String?
|
||||
private var videoDirectories: [String: URL] = [:]
|
||||
private var completedVideos: [String: [String: Any]] = [:]
|
||||
private var videoBytesRetained = 0
|
||||
private var currentVideoID: String?
|
||||
private var videoIsRecording = false
|
||||
private var videoStopRequestIDs: [String: String] = [:]
|
||||
private struct VideoFileIdentity: Equatable, Sendable {
|
||||
let device: UInt64, inode: UInt64
|
||||
let size: Int
|
||||
let seconds: Int64, nanos: Int64
|
||||
init(_ info: stat) {
|
||||
device = UInt64(info.st_dev); inode = UInt64(info.st_ino); size = Int(info.st_size)
|
||||
seconds = Int64(info.st_mtimespec.tv_sec); nanos = Int64(info.st_mtimespec.tv_nsec)
|
||||
}
|
||||
}
|
||||
private var videoFileIdentities: [String: VideoFileIdentity] = [:]
|
||||
private let videoArtifactWillVerify: (@Sendable (URL) throws -> Void)?
|
||||
|
||||
private func retainVideoMetadata(_ result: [String: Any]) async throws {
|
||||
guard let metadata = (result["video"] ?? result["video_recording"]) as? [String: Any] else { return }
|
||||
videoIsRecording = metadata["status"] as? String == "recording"
|
||||
guard metadata["completed"] as? Bool == true else { return }
|
||||
guard let id = metadata["clip_id"] as? String, let directory = videoDirectories[id] else { throw Self.failure("invalid_playtest_video") }
|
||||
if completedVideos[id] != nil { return }
|
||||
let url = directory.appendingPathComponent("Clip.mp4")
|
||||
let expectedCount = (metadata["byte_count"] as? NSNumber)?.intValue
|
||||
let expectedHash = metadata["sha256"] as? String
|
||||
let willVerify = videoArtifactWillVerify
|
||||
let identity = try await Task.detached {
|
||||
try willVerify?(url)
|
||||
let fd = open(url.path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC | O_NONBLOCK)
|
||||
guard fd >= 0 else { throw Self.failure("invalid_playtest_video") }
|
||||
let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
|
||||
defer { try? handle.close() }
|
||||
var info = stat()
|
||||
guard fstat(fd, &info) == 0, info.st_mode & S_IFMT == S_IFREG,
|
||||
(1...Self.videoByteLimit).contains(Int(info.st_size)), Int(info.st_size) == expectedCount else {
|
||||
throw Self.failure("invalid_playtest_video")
|
||||
}
|
||||
let identity = VideoFileIdentity(info)
|
||||
let bytes = try handle.read(upToCount: identity.size + 1) ?? Data()
|
||||
guard bytes.count == identity.size, CMOCProject.sha256(bytes) == expectedHash,
|
||||
fstat(fd, &info) == 0, VideoFileIdentity(info) == identity else { throw Self.failure("invalid_playtest_video") }
|
||||
return identity
|
||||
}.value
|
||||
guard let count = expectedCount, videoBytesRetained <= Self.videoRetainedByteLimit - count else { throw Self.failure("playtest_video_retention_limit") }
|
||||
videoBytesRetained += count; completedVideos[id] = metadata; videoFileIdentities[id] = identity
|
||||
}
|
||||
|
||||
private func readVideo(_ arguments: [String: Any]) async throws -> [String: Any] {
|
||||
guard Set(arguments.keys).isSubset(of: ["run_id", "clip_id", "offset", "limit"]),
|
||||
let id = arguments["clip_id"] as? String, let metadata = completedVideos[id], let directory = videoDirectories[id],
|
||||
let total = (metadata["byte_count"] as? NSNumber)?.intValue,
|
||||
let identity = videoFileIdentities[id] else { throw Self.failure("playtest_video_unavailable") }
|
||||
func integer(_ value: Any?, fallback: Int, range: ClosedRange<Int>) throws -> Int {
|
||||
guard let value else { return fallback }
|
||||
guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(), number.doubleValue.isFinite,
|
||||
number.doubleValue == Double(number.intValue), range.contains(number.intValue) else { throw Self.failure("invalid_arguments") }
|
||||
return number.intValue
|
||||
}
|
||||
let offset = try integer(arguments["offset"], fallback: 0, range: 0...total)
|
||||
let limit = try integer(arguments["limit"], fallback: 65536, range: 1...65536)
|
||||
let url = directory.appendingPathComponent("Clip.mp4")
|
||||
let data = try await Task.detached {
|
||||
let fd = open(url.path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC | O_NONBLOCK)
|
||||
guard fd >= 0 else { throw Self.failure("invalid_playtest_video") }
|
||||
let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
|
||||
defer { try? handle.close() }
|
||||
var info = stat()
|
||||
guard fstat(fd, &info) == 0, info.st_mode & S_IFMT == S_IFREG, VideoFileIdentity(info) == identity else { throw Self.failure("invalid_playtest_video") }
|
||||
try handle.seek(toOffset: UInt64(offset))
|
||||
let count = min(limit, total - offset)
|
||||
let bytes = try handle.read(upToCount: count) ?? Data()
|
||||
guard bytes.count == count, fstat(fd, &info) == 0, VideoFileIdentity(info) == identity else { throw Self.failure("invalid_playtest_video") }
|
||||
return bytes
|
||||
}.value
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
var result = metadata
|
||||
result["video_chunk_base64"] = data.base64EncodedString(); result["offset"] = offset
|
||||
result["next_offset"] = offset + data.count; result["eof"] = offset + data.count == total
|
||||
return scoped(result)
|
||||
}
|
||||
|
||||
private struct MediumState {
|
||||
let source: MCPPlaytestMedium
|
||||
@@ -413,11 +499,13 @@ 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]?,
|
||||
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.videoArtifactWillVerify = videoArtifactWillVerify
|
||||
if let media {
|
||||
self.media = Dictionary(uniqueKeysWithValues: media.map { ($0.id, MediumState(source: $0, data: $0.data)) })
|
||||
self.mediaOrder = media.map(\.id); self.mountedMediaID = media.first?.id
|
||||
@@ -429,7 +517,8 @@ 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) async throws -> MCPPlaytest {
|
||||
media: [MCPPlaytestMedium]? = nil,
|
||||
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,
|
||||
["6809", "6309"].contains(cpu), bootCommands.utf8.count <= 256 else { throw failure("invalid_playtest_artifact") }
|
||||
@@ -472,7 +561,7 @@ 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)
|
||||
processor: cpu == "6309" ? .hd6309 : .mc6809, media: media, 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,
|
||||
@@ -550,6 +639,10 @@ final class MCPPlaytest {
|
||||
throw Self.failure("playtest_disk_export_failed")
|
||||
}
|
||||
exportedDisk = Data(data); exportedStatus = result
|
||||
// Video is an independent artifact. A missing or corrupt movie may
|
||||
// never prevent retention of the guest's writable disk bytes.
|
||||
do { try await retainVideoMetadata(result) }
|
||||
catch { exportedStatus?["video_retention_error"] = "The video artifact could not be verified; disk retention continues." }
|
||||
}
|
||||
guard let data = exportedDisk else { throw Self.failure("playtest_disk_export_failed") }
|
||||
do {
|
||||
@@ -695,6 +788,8 @@ final class MCPPlaytest {
|
||||
do {
|
||||
result = try await worker.request(["op": "stop"])
|
||||
try receiveMediaExport(result)
|
||||
do { try await retainVideoMetadata(result) }
|
||||
catch { result["video_retention_error"] = "The video artifact could not be verified; disk retention continues." }
|
||||
} catch let error as WorkerTransportFailure {
|
||||
// A failed swap pipe cannot have advanced a paused guest.
|
||||
// Every candidate copy is already frozen in the host; retain
|
||||
@@ -771,6 +866,7 @@ final class MCPPlaytest {
|
||||
if exportedDisk != nil { return scoped(["status": "retention_pending", "disk_retained": false]) }
|
||||
let result = try await worker.request(["op": "capture"])
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
try await retainVideoMetadata(result)
|
||||
return scoped(result)
|
||||
}
|
||||
if tool == "get_playtest_input" {
|
||||
@@ -779,8 +875,9 @@ final class MCPPlaytest {
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
return scoped(result)
|
||||
}
|
||||
if tool == "read_playtest_video" { return try await readVideo(arguments) }
|
||||
guard let requestID = arguments["request_id"] as? String, (1...64).contains(requestID.utf8.count),
|
||||
["playtest_input", "restart_playtest", "stop_playtest", "playtest_debug", "capture_playtest_audio", "exchange_playtest_media"].contains(tool) else { throw Self.failure("invalid_arguments") }
|
||||
["playtest_input", "restart_playtest", "stop_playtest", "playtest_debug", "capture_playtest_audio", "exchange_playtest_media", "start_playtest_video", "stop_playtest_video"].contains(tool) else { throw Self.failure("invalid_arguments") }
|
||||
let signature = try JSONSerialization.data(withJSONObject: ["tool": tool, "arguments": arguments], options: [.sortedKeys])
|
||||
if let (prior, reason) = mediaFailures[requestID] {
|
||||
guard signature == prior else { throw Self.failure("request_conflict") }
|
||||
@@ -793,11 +890,15 @@ final class MCPPlaytest {
|
||||
if tool == "stop_playtest", let stopRequestID, requestID != stopRequestID {
|
||||
throw Self.failure("request_conflict: retry the original stop request_id")
|
||||
}
|
||||
if tool == "stop_playtest_video", let clip = currentVideoID,
|
||||
let prior = videoStopRequestIDs[clip], prior != requestID {
|
||||
throw Self.failure("request_conflict: retry the original video stop request_id")
|
||||
}
|
||||
guard exportedDisk == nil || tool == "stop_playtest" else { throw Self.failure("playtest_retention_pending") }
|
||||
guard !finished else { throw Self.failure("stale_run") }
|
||||
// Cleanup has its own single cached receipt and must remain possible
|
||||
// after any execution/audio budget is exhausted.
|
||||
guard tool == "stop_playtest" || mutationRequestsAccepted < Self.mutationRequestLimit || accepted[requestID] != nil else {
|
||||
guard ["stop_playtest", "stop_playtest_video"].contains(tool) || mutationRequestsAccepted < Self.mutationRequestLimit || accepted[requestID] != nil else {
|
||||
throw Self.failure("playtest_request_limit")
|
||||
}
|
||||
if tool == "exchange_playtest_media" {
|
||||
@@ -843,6 +944,31 @@ final class MCPPlaytest {
|
||||
}
|
||||
var request: [String: Any]
|
||||
switch tool {
|
||||
case "start_playtest_video":
|
||||
guard Set(arguments.keys).isSubset(of: ["run_id", "request_id", "include_audio", "max_fields"]) else { throw Self.failure("invalid_arguments") }
|
||||
guard !videoIsRecording else { throw Self.failure("playtest_video_active") }
|
||||
let includeAudio: Bool
|
||||
if let value = arguments["include_audio"] {
|
||||
guard let number = value as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw Self.failure("invalid_arguments") }
|
||||
includeAudio = number.boolValue
|
||||
} else { includeAudio = true }
|
||||
let maximum: Int
|
||||
if let value = arguments["max_fields"] {
|
||||
guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(), number.doubleValue.isFinite,
|
||||
number.doubleValue == Double(number.intValue), (1...Self.videoFieldLimit).contains(number.intValue) else { throw Self.failure("invalid_arguments") }
|
||||
maximum = number.intValue
|
||||
} else { maximum = 1800 }
|
||||
guard videoDirectories.count < Self.videoClipLimit, videoBytesRetained <= Self.videoRetainedByteLimit - Self.videoByteLimit else {
|
||||
throw Self.failure("playtest_video_capture_limit")
|
||||
}
|
||||
let id = UUID().uuidString
|
||||
let directory = retentionDirectory.appendingPathComponent("Videos", isDirectory: true).appendingPathComponent(runID, isDirectory: true).appendingPathComponent(id, isDirectory: true)
|
||||
try await Task.detached { try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700]) }.value
|
||||
videoDirectories[id] = directory; currentVideoID = id
|
||||
request = ["op": "video_start", "clip_id": id, "directory": directory.path, "include_audio": includeAudio, "max_fields": maximum]
|
||||
case "stop_playtest_video":
|
||||
guard arguments.count == 2, currentVideoID != nil else { throw Self.failure("playtest_video_unavailable") }
|
||||
request = ["op": "video_stop"]
|
||||
case "capture_playtest_audio":
|
||||
guard arguments.count == 3, let n = arguments["fields"] as? NSNumber,
|
||||
CFGetTypeID(n) != CFBooleanGetTypeID(), n.doubleValue.isFinite,
|
||||
@@ -892,6 +1018,7 @@ final class MCPPlaytest {
|
||||
}
|
||||
case "restart_playtest":
|
||||
guard arguments.count == 2 else { throw Self.failure("invalid_arguments") }
|
||||
guard !videoIsRecording else { throw Self.failure("playtest_video_active: stop the recording before restarting") }
|
||||
request = ["op": "restart"]
|
||||
default:
|
||||
guard arguments.count == 2 else { throw Self.failure("invalid_arguments") }
|
||||
@@ -900,7 +1027,8 @@ final class MCPPlaytest {
|
||||
// Reserve the identity before execution. An interrupted operation must
|
||||
// never be retried as a new input sequence with the same request ID.
|
||||
if tool == "stop_playtest" { stopRequestID = requestID }
|
||||
if tool != "stop_playtest" { mutationRequestsAccepted += 1 }
|
||||
if tool == "stop_playtest_video", let clip = currentVideoID { videoStopRequestIDs[clip] = requestID }
|
||||
if !["stop_playtest", "stop_playtest_video"].contains(tool) { mutationRequestsAccepted += 1 }
|
||||
if tool == "capture_playtest_audio" { audioCapturesAccepted += 1 }
|
||||
accepted[requestID] = (signature, scoped(["request_id": requestID, "status": "interrupted"]))
|
||||
if tool == "stop_playtest" {
|
||||
@@ -920,6 +1048,7 @@ final class MCPPlaytest {
|
||||
lastSafeMediaExport = nil
|
||||
var result = try await worker.request(request)
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
try await retainVideoMetadata(result)
|
||||
if tool == "capture_playtest_audio" {
|
||||
guard let encoded = result["audio_wav_base64"] as? String,
|
||||
let wav = Data(base64Encoded: encoded), (44...Self.maximumAudioClipBytes).contains(wav.count),
|
||||
@@ -963,6 +1092,7 @@ final class MCPPlaytest {
|
||||
if let operation = request["op"] as? String, ["continue", "step", "stop_at"].contains(operation) { lastSafeMediaExport = nil }
|
||||
let result = try await worker.request(request)
|
||||
guard valid else { throw Self.failure("stale_run") }
|
||||
try await retainVideoMetadata(result)
|
||||
return scoped(result)
|
||||
}
|
||||
|
||||
@@ -975,6 +1105,12 @@ final class MCPPlaytest {
|
||||
result["mutation_requests_used"] = mutationRequestsAccepted
|
||||
result["remaining_mutation_requests"] = max(0, Self.mutationRequestLimit - mutationRequestsAccepted)
|
||||
result["stop_retention_exempt"] = true
|
||||
result["video_stop_retention_exempt"] = true
|
||||
result["video_clip_limit"] = Self.videoClipLimit
|
||||
result["remaining_video_clips"] = max(0, Self.videoClipLimit - videoDirectories.count)
|
||||
result["video_byte_limit"] = Self.videoByteLimit
|
||||
result["video_retained_byte_limit"] = Self.videoRetainedByteLimit
|
||||
result["remaining_video_bytes"] = max(0, Self.videoRetainedByteLimit - videoBytesRetained)
|
||||
result["audio_capture_limit"] = Self.audioCaptureLimit
|
||||
result["remaining_audio_captures"] = max(0, Self.audioCaptureLimit - audioCapturesAccepted)
|
||||
result["audio_byte_limit"] = Self.audioByteLimit
|
||||
|
||||
Reference in new issue
Block a user