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:
Brian Holman committed 2026-11-17 08:42:27 -07:00
1 parent 4abc194001
commit 5534005799
54 files changed
+2950 -435

No files matched your search

+272
View File
@@ -0,0 +1,272 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Darwin
/// A connection-scoped, revocable write grant. It never follows a user-selected
/// path supplied over MCP: the destination was selected in the native app.
final class MCPBuildExporter: @unchecked Sendable {
static let maximumFiles = 64
static let maximumSetBytes = 128 * 1024 * 1024
static let maximumSessionBytes = 512 * 1024 * 1024
static let maximumRequests = 64
struct Identity: Equatable, Sendable {
let device: dev_t
let inode: ino_t
init(_ value: stat) { device = value.st_dev; inode = value.st_ino }
}
struct Source: Sendable {
let artifactID: UUID
let directory: URL
let products: [CMOCBuildOutputProduct]
let identity: Identity
init(_ artifact: CMOCBuildArtifact) throws {
artifactID = artifact.id; directory = artifact.directory; products = artifact.exportProducts
let fd = try MCPBuildExporter.directory(artifact.directory)
defer { close(fd) }
identity = try MCPBuildExporter.identity(fd)
}
}
struct Delivery: Sendable {
let directory: String
let products: [CMOCBuildOutputProduct]
}
let destinationID = UUID().uuidString
private let root: URL
private let rootIdentity: Identity
private let state = NSLock()
private var valid = true
// Only used by authored race/failure fixtures, never populated by public input.
var beforeCommit: (@Sendable () throws -> Void)?
var afterFile: (@Sendable (Int) throws -> Void)?
init(destination: URL) throws {
root = destination.standardizedFileURL
let fd = try Self.directory(root); defer { close(fd) }
rootIdentity = try Self.identity(fd)
}
func invalidate() { state.lock(); valid = false; state.unlock() }
private func check() throws {
try Task.checkCancellation()
state.lock(); defer { state.unlock() }
guard valid else { throw Self.failure("access_denied") }
}
private static func failure(_ text: String) -> CMOCBuildError { .message(text) }
private static func identity(_ descriptor: Int32) throws -> Identity {
var value = stat()
guard fstat(descriptor, &value) == 0, value.st_mode & S_IFMT == S_IFDIR else {
throw failure("export_directory_unavailable")
}
return Identity(value)
}
/// Follow only Apple's standard /tmp and /var aliases, never arbitrary links.
private static func canonicalPath(_ url: URL) -> String {
let path = url.standardizedFileURL.path
return path == "/tmp" || path.hasPrefix("/tmp/") || path == "/var" || path.hasPrefix("/var/") ? "/private" + path : path
}
private static func directory(_ url: URL) throws -> Int32 {
let normalized = canonicalPath(url)
guard normalized.hasPrefix("/") else { throw failure("invalid_export_directory") }
var held = open("/", O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard held >= 0 else { throw failure("export_directory_unavailable") }
do {
for component in normalized.split(separator: "/") {
let next = openat(held, String(component), O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard next >= 0 else { throw failure("export_directory_changed_or_linked") }
close(held); held = next
}
return held
} catch { close(held); throw error }
}
private func destination() throws -> Int32 {
try check()
let fd = try Self.directory(root)
do {
guard try Self.identity(fd) == rootIdentity else { throw Self.failure("export_destination_changed") }
return fd
} catch { close(fd); throw error }
}
private func source(_ value: Source) throws -> Int32 {
try check()
let fd = try Self.directory(value.directory)
do {
guard try Self.identity(fd) == value.identity else { throw Self.failure("export_artifact_changed") }
return fd
} catch { close(fd); throw error }
}
private static func parent(_ root: Int32, path: String, create: Bool) throws -> (Int32, String) {
try CMOCProject.validateRelativePath(path)
let components = path.split(separator: "/").map(String.init)
guard components.count <= 32, components.allSatisfy({ $0.utf8.count <= 255 }) else { throw failure("invalid_export_path") }
var held = dup(root)
guard held >= 0 else { throw failure("export_directory_unavailable") }
do {
for component in components.dropLast() {
if create, mkdirat(held, component, 0o700) != 0, errno != EEXIST { throw failure("export_write_failed") }
let next = openat(held, component, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard next >= 0 else { throw failure("export_path_changed_or_linked") }
close(held); held = next
}
return (held, components.last!)
} catch { close(held); throw error }
}
private func read(_ product: CMOCBuildOutputProduct, from directory: Int32) throws -> Data {
try check()
guard (0...CMOCProject.maximumFileBytes).contains(product.byteCount) else { throw Self.failure("export_output_too_large") }
let (parent, leaf) = try Self.parent(directory, path: product.relativePath, create: false)
defer { close(parent) }
let fd = openat(parent, leaf, O_RDONLY | O_NOFOLLOW | O_NONBLOCK | O_CLOEXEC)
guard fd >= 0 else { throw Self.failure("export_output_unavailable") }
let file = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
defer { try? file.close() }
var before = stat()
guard fstat(fd, &before) == 0, before.st_mode & S_IFMT == S_IFREG, before.st_nlink == 1,
before.st_size == off_t(product.byteCount) else { throw Self.failure("export_output_changed_or_linked") }
var data = Data()
while data.count < product.byteCount {
try check()
let chunk = try file.read(upToCount: min(65536, product.byteCount - data.count)) ?? Data()
guard !chunk.isEmpty else { throw Self.failure("export_output_changed") }
data.append(chunk)
}
var after = stat(), named = stat()
guard fstat(fd, &after) == 0, Identity(before) == Identity(after), before.st_size == after.st_size,
before.st_mtimespec.tv_sec == after.st_mtimespec.tv_sec, before.st_mtimespec.tv_nsec == after.st_mtimespec.tv_nsec,
fstatat(parent, leaf, &named, AT_SYMLINK_NOFOLLOW) == 0,
named.st_mode & S_IFMT == S_IFREG, named.st_nlink == 1, Identity(named) == Identity(after),
CMOCProject.sha256(data) == product.sha256 else { throw Self.failure("export_output_changed") }
return data
}
private func verifyContents(_ descriptor: Int32, products: [CMOCBuildOutputProduct], flush: Bool = false) throws {
let expected = Set(products.map(\.relativePath))
var observed: Set<String> = []
var visited = 0
func walk(_ fd: Int32, prefix: String, depth: Int) throws {
try check()
guard depth <= 32 else { throw Self.failure("export_delivery_changed") }
let copy = dup(fd)
guard copy >= 0, let stream = fdopendir(copy) else {
if copy >= 0 { close(copy) }; throw Self.failure("export_delivery_changed")
}
defer { closedir(stream) }
while let entry = readdir(stream) {
let name = withUnsafePointer(to: &entry.pointee.d_name) {
$0.withMemoryRebound(to: CChar.self, capacity: Int(entry.pointee.d_namlen) + 1) { String(cString: $0) }
}
if name == "." || name == ".." { continue }
visited += 1
guard visited <= Self.maximumFiles * 33 else { throw Self.failure("export_delivery_changed") }
let path = prefix.isEmpty ? name : prefix + "/" + name
var info = stat()
guard fstatat(fd, name, &info, AT_SYMLINK_NOFOLLOW) == 0 else { throw Self.failure("export_delivery_changed") }
if info.st_mode & S_IFMT == S_IFDIR {
guard expected.contains(where: { $0.hasPrefix(path + "/") }) else { throw Self.failure("export_delivery_changed") }
let child = openat(fd, name, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard child >= 0 else { throw Self.failure("export_delivery_changed") }
defer { close(child) }
try walk(child, prefix: path, depth: depth + 1)
} else {
guard info.st_mode & S_IFMT == S_IFREG, info.st_nlink == 1, expected.contains(path) else { throw Self.failure("export_delivery_changed") }
observed.insert(path)
}
}
if flush, fsync(fd) != 0 { throw Self.failure("export_write_failed") }
}
try walk(descriptor, prefix: "", depth: 0)
guard observed == expected else { throw Self.failure("export_delivery_changed") }
for product in products { _ = try read(product, from: descriptor) }
}
/// Creates a complete new set with an exclusive atomic directory rename.
/// No existing delivery is removed or repaired. The caller binds Source and
/// the request ID to the original connection/build/revision before calling.
func export(source value: Source, products: [CMOCBuildOutputProduct], setName: String) throws -> Delivery {
guard !products.isEmpty, products.count <= Self.maximumFiles,
Set(products.map { $0.relativePath.lowercased() }).count == products.count,
products.allSatisfy({ value.products.contains($0) && (0...CMOCProject.maximumFileBytes).contains($0.byteCount) }),
products.reduce(0, { $0 + $1.byteCount }) <= Self.maximumSetBytes,
setName.hasPrefix("VCC-"), setName.utf8.count < 200, !setName.contains("/") else { throw Self.failure("invalid_export_selection") }
let sourcePath = Self.canonicalPath(value.directory), destinationPath = Self.canonicalPath(root)
guard destinationPath != sourcePath, !destinationPath.hasPrefix(sourcePath + "/") else { throw Self.failure("export_destination_overlaps_artifact") }
let destination = try destination(), source = try source(value)
defer { close(destination); close(source) }
let stageName = ".vccplus-export-" + UUID().uuidString
guard mkdirat(destination, stageName, 0o700) == 0 else { throw Self.failure("export_write_failed") }
let stage = openat(destination, stageName, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard stage >= 0 else { throw Self.failure("export_write_failed") }
defer { close(stage) }
var created: [(String, Identity)] = []
var committed = false
defer {
if !committed {
// Remove only this transaction's unchanged files; never recursively
// erase unexpected files planted in a failed staging directory.
for (path, identity) in created.reversed() {
if let (parent, leaf) = try? Self.parent(stage, path: path, create: false) {
var named = stat()
if fstatat(parent, leaf, &named, AT_SYMLINK_NOFOLLOW) == 0, Identity(named) == identity { _ = unlinkat(parent, leaf, 0) }
close(parent)
}
}
let directories = Set(products.flatMap { product -> [String] in
let parts = product.relativePath.split(separator: "/"); return (1..<parts.count).map { parts.prefix($0).joined(separator: "/") }
}).sorted { $0.count > $1.count }
for path in directories {
if let (parent, leaf) = try? Self.parent(stage, path: path, create: false) { _ = unlinkat(parent, leaf, AT_REMOVEDIR); close(parent) }
}
_ = unlinkat(destination, stageName, AT_REMOVEDIR)
}
}
for (index, product) in products.enumerated() {
let checkDestination = try self.destination(); close(checkDestination)
let checkSource = try self.source(value); close(checkSource)
let bytes = try read(product, from: source)
let (parent, leaf) = try Self.parent(stage, path: product.relativePath, create: true)
defer { close(parent) }
let fd = openat(parent, leaf, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC, 0o600)
guard fd >= 0 else { throw Self.failure("export_write_failed") }
let file = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
defer { try? file.close() }
var info = stat()
guard fstat(fd, &info) == 0 else { throw Self.failure("export_write_failed") }
created.append((product.relativePath, Identity(info)))
for offset in stride(from: 0, to: bytes.count, by: 65536) {
try check()
try file.write(contentsOf: bytes.subdata(in: offset..<min(bytes.count, offset + 65536)))
}
guard fsync(fd) == 0 else { throw Self.failure("export_write_failed") }
try afterFile?(index)
}
// Verify the actual staged bytes and source hashes again before commit.
for product in products { _ = try read(product, from: stage); _ = try read(product, from: source) }
try beforeCommit?()
try verifyContents(stage, products: products, flush: true)
for product in products { _ = try read(product, from: source) }
let currentDestination = try self.destination(), currentSource = try self.source(value)
defer { close(currentDestination); close(currentSource) }
var stageInfo = stat(), namedStage = stat()
guard fstat(stage, &stageInfo) == 0, fstatat(destination, stageName, &namedStage, AT_SYMLINK_NOFOLLOW) == 0,
namedStage.st_mode & S_IFMT == S_IFDIR, Identity(stageInfo) == Identity(namedStage) else { throw Self.failure("export_staging_changed") }
try check()
// Revocation cannot race between the final authority check and rename.
state.lock()
guard valid, !Task.isCancelled else { state.unlock(); throw Self.failure("access_denied") }
let renamed = renameatx_np(destination, stageName, destination, setName, UInt32(RENAME_EXCL))
let renameError = errno
if renamed == 0 { committed = true }
state.unlock()
guard renamed == 0 else {
throw Self.failure(renameError == EEXIST ? "export_destination_conflict" : "export_commit_failed")
}
// The staged file data was flushed before rename; never delete an exposed
// delivery to roll back a directory-flush failure.
guard fsync(destination) == 0 else { throw Self.failure("export_commit_uncertain") }
return Delivery(directory: setName, products: products)
}
func verify(_ delivery: Delivery) throws {
let destination = try destination(); defer { close(destination) }
let directory = openat(destination, delivery.directory, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
guard directory >= 0 else { throw Self.failure("export_delivery_changed") }
defer { close(directory) }
try verifyContents(directory, products: delivery.products)
let current = try self.destination(); close(current)
}
}