Sync source edition with VCC Plus 3.7.0 build 63

This commit is contained in:
Brian Holman committed 2026-11-14 01:43:46 -07:00
1 parent c652a5276d
commit b2ecec4d87
86 files changed
+10519 -472

No files matched your search

+142 -6
View File
@@ -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