Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,741 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import AppKit
|
||||
import Combine
|
||||
import SwiftUI
|
||||
|
||||
struct AssemblyProjectEdit {
|
||||
let path: String
|
||||
let before: String
|
||||
let after: String
|
||||
}
|
||||
|
||||
@MainActor
|
||||
private final class AssemblyAccessWindowDelegate: NSObject, NSWindowDelegate {
|
||||
let didClose: @MainActor (NSWindow) -> Void
|
||||
init(didClose: @escaping @MainActor (NSWindow) -> Void) { self.didClose = didClose; super.init() }
|
||||
func windowWillClose(_ notification: Notification) {
|
||||
if let window = notification.object as? NSWindow { didClose(window) }
|
||||
}
|
||||
}
|
||||
|
||||
/// A connection is bound to one native assembly document and its original source-file set.
|
||||
@MainActor
|
||||
final class MCPAssembly: ObservableObject {
|
||||
static let shared = MCPAssembly()
|
||||
static let tools = ["get_capabilities", "get_machine_status", "get_debug_snapshot", "read_debug_memory", "search_help", "read_topic", "read_project_file", "build_project", "get_build", "propose_fix", "propose_project_edits", "get_proposal", "get_run", "read_screen_text", "send_keys"]
|
||||
private weak var model: AssemblyDevelopmentModel?
|
||||
private weak var editors: AssemblyEditorPool?
|
||||
private var transport: MCPTransport?
|
||||
private var file: MCPGrantFile?
|
||||
fileprivate var grantURL: URL? { file?.url }
|
||||
private var scope = UUID()
|
||||
private var token = ""
|
||||
private var documentID: UUID?
|
||||
private var files: Set<String> = []
|
||||
private var last: AssemblyProjectSnapshot?
|
||||
private var lastSourceRevision: UUID?
|
||||
private var revision = 0
|
||||
private var selection: AnyCancellable?
|
||||
private var editObservation: AnyCancellable?
|
||||
private var window: NSPanel?
|
||||
private var windowPresentation = UUID()
|
||||
private lazy var windowDelegate = AssemblyAccessWindowDelegate { [weak self] closing in
|
||||
guard let self, self.window === closing else { return }
|
||||
self.windowPresentation = UUID()
|
||||
}
|
||||
private var buildTask: Task<Void, Never>?
|
||||
private var requests: [String: (tool: String, args: NSDictionary, id: String)] = [:]
|
||||
private var latestBuildID: String?
|
||||
private var builds: [String: [String: Any]] = [:]
|
||||
private var proposals: [String: [String: Any]] = [:]
|
||||
private var built: (id: String, revision: Int, artifact: AssemblyBuildArtifact)?
|
||||
private var inspection: MCPDebuggerInspection?
|
||||
private var runIO: MCPCompiledRunIO?
|
||||
private var run: (id: String, revision: Int, build: String, machine: VCCMachineSnapshot)? {
|
||||
willSet { runIO?.invalidate(); runIO = nil }
|
||||
}
|
||||
private var runMessage = "No run started."
|
||||
@Published private(set) var connected = false
|
||||
@Published private(set) var canRun = false
|
||||
@Published private(set) var status = ""
|
||||
@Published private(set) var proposal: Proposal?
|
||||
|
||||
struct Proposal: Identifiable {
|
||||
enum Content {
|
||||
case line(path: String, number: Int, before: String, after: String)
|
||||
case files([AssemblyProjectEdit])
|
||||
}
|
||||
let id: String
|
||||
let revision: Int
|
||||
let content: Content
|
||||
}
|
||||
private struct AppliedFiles {
|
||||
let proposal: Proposal
|
||||
let revision: Int
|
||||
let removedStops: Set<AssemblyDevelopmentModel.SourceLine>
|
||||
}
|
||||
@Published private var appliedFiles: AppliedFiles?
|
||||
fileprivate var runnableBuildID: String? { canRun ? built?.id : nil }
|
||||
fileprivate var undoableProposalID: String? { proposal == nil ? appliedFiles?.proposal.id : nil }
|
||||
|
||||
func show(_ model: AssemblyDevelopmentModel, editors: AssemblyEditorPool) {
|
||||
windowPresentation = UUID()
|
||||
if self.model !== model { revoke() }
|
||||
self.model = model
|
||||
self.editors = editors
|
||||
let panel = window ?? NSPanel(contentRect: NSRect(x: 0, y: 0, width: 670, height: 460),
|
||||
styleMask: [.titled, .closable, .resizable], backing: .buffered, defer: false)
|
||||
panel.title = "Assembly Assistant Access"
|
||||
panel.isReleasedWhenClosed = false
|
||||
panel.delegate = windowDelegate
|
||||
panel.contentView = NSHostingView(rootView: AssemblyAccessView(access: self, model: model))
|
||||
if window == nil { panel.center() }
|
||||
window = panel
|
||||
panel.makeKeyAndOrderFront(nil)
|
||||
}
|
||||
|
||||
func close(for model: AssemblyDevelopmentModel) {
|
||||
guard self.model === model else { return }
|
||||
revoke()
|
||||
window?.close()
|
||||
window = nil
|
||||
}
|
||||
|
||||
fileprivate func choose(_ model: AssemblyDevelopmentModel) {
|
||||
guard let owner = window, self.model === model, owner.isVisible,
|
||||
!owner.isMiniaturized, owner.attachedSheet == nil else { return }
|
||||
let document = model.activeID, generation = scope, presentation = windowPresentation
|
||||
let panel = NSSavePanel()
|
||||
panel.title = "Save Assembly Connection"
|
||||
panel.nameFieldStringValue = "VCC Plus OSS Assembly Connection.json"
|
||||
panel.beginSheetModal(for: owner) { [weak self, weak owner, weak model] response in
|
||||
Task { @MainActor [weak self, weak owner, weak model] in
|
||||
guard let self, let owner, let model else { return }
|
||||
@MainActor func currentPresentation() -> Bool {
|
||||
self.windowPresentation == presentation && self.window === owner && self.model === model && owner.isVisible &&
|
||||
!owner.isMiniaturized && model.activeID == document
|
||||
}
|
||||
guard currentPresentation(), self.scope == generation else { return }
|
||||
defer { if currentPresentation() { owner.makeKeyAndOrderFront(nil) } }
|
||||
guard response == .OK, let url = panel.url else { return }
|
||||
do { try await self.connect(model, to: url, presentationIsCurrent: currentPresentation) }
|
||||
catch is CancellationError { }
|
||||
catch { if currentPresentation() { self.status = error.localizedDescription } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func revoke() {
|
||||
inspection = nil
|
||||
scope = UUID(); token = ""; connected = false; documentID = nil; selection = nil; editObservation = nil
|
||||
requests.removeAll(); builds.removeAll(); latestBuildID = nil; proposals.removeAll()
|
||||
buildTask?.cancel(); buildTask = nil
|
||||
proposal = nil; appliedFiles = nil; built = nil; last = nil; run = nil; runMessage = "No run started."
|
||||
canRun = false; status = ""; files.removeAll(); revision = 0
|
||||
let old = transport, oldFile = file
|
||||
transport = nil; file = nil
|
||||
Task.detached { old?.stop(); oldFile?.remove() }
|
||||
}
|
||||
|
||||
private static func sourcePaths(_ snapshot: AssemblyProjectSnapshot) throws -> Set<String> {
|
||||
guard snapshot.settings.makefile == nil, snapshot.settings.linkScript == nil,
|
||||
(snapshot.settings.modules ?? []).isEmpty else {
|
||||
throw AssemblyBuildFailure("Share a native direct-assembly project. Linked projects and Make recipes require the local workspace.")
|
||||
}
|
||||
let paths = Set(snapshot.files.keys.filter { $0 != AssemblyProjectSnapshot.configurationFilename })
|
||||
let extensions = ["asm", "s", "inc", "lwasm", "a09"]
|
||||
guard paths.contains(snapshot.mainPath), paths.count <= 32, snapshot.files.values.reduce(0, { $0 + $1.count }) <= 512 * 1024,
|
||||
paths.allSatisfy({ path in
|
||||
guard extensions.contains((path as NSString).pathExtension.lowercased()), let data = snapshot.files[path] else { return false }
|
||||
return data.count <= 64 * 1024 && !data.contains(0) && String(data: data, encoding: .utf8) != nil
|
||||
}) else { throw AssemblyBuildFailure("Share a project containing up to 32 UTF-8 assembly or include files, 64 KiB per file.") }
|
||||
return paths
|
||||
}
|
||||
|
||||
func connect(_ model: AssemblyDevelopmentModel, to url: URL,
|
||||
presentationIsCurrent: (@MainActor () -> Bool)? = nil) async throws {
|
||||
revoke(); self.model = model
|
||||
let ticket = scope, doc = model.document, version = model.workspaceRevision
|
||||
let snapshot = try await Task.detached { try doc.snapshot() }.value
|
||||
guard scope == ticket, model.activeID == doc.id, model.workspaceRevision == version,
|
||||
presentationIsCurrent?() != false else { throw CancellationError() }
|
||||
let paths = try Self.sourcePaths(snapshot)
|
||||
let key = UUID().uuidString + UUID().uuidString
|
||||
let handler: MCPTransport.Handler = { [weak self] bytes in
|
||||
guard let self else { return Data(#"{"error":"access_denied"}"#.utf8) }
|
||||
return await self.reply(bytes, ticket: ticket)
|
||||
}
|
||||
let pair = try await Task.detached {
|
||||
let server = try MCPTransport(handler: handler)
|
||||
let info: [String: Any] = ["kind": "assembly", "toolset": 3, "socket": server.unixPath, "port": Int(server.port), "version": 1, "token": key]
|
||||
return (server, try MCPGrantFile(create: url, data: JSONSerialization.data(withJSONObject: info)))
|
||||
}.value
|
||||
guard scope == ticket, model.activeID == doc.id, model.workspaceRevision == version,
|
||||
presentationIsCurrent?() != false else {
|
||||
Task.detached { pair.0.stop(); pair.1.remove() }
|
||||
throw CancellationError()
|
||||
}
|
||||
last = snapshot; lastSourceRevision = model.sourceRevision; files = paths; revision = 1
|
||||
documentID = doc.id; token = key; transport = pair.0; file = pair.1
|
||||
connected = true; status = "Sharing " + doc.title
|
||||
editObservation = model.$sourceRevision.dropFirst().sink { [weak self] _ in self?.runIO?.invalidate() }
|
||||
selection = model.$activeID.dropFirst().sink { [weak self] _ in self?.revoke() }
|
||||
}
|
||||
|
||||
private func snapshot(_ model: AssemblyDevelopmentModel, ticket: UUID, retry: Bool = true) async throws -> AssemblyProjectSnapshot {
|
||||
let doc = model.document, version = model.workspaceRevision
|
||||
let value = try await Task.detached { try doc.snapshot() }.value
|
||||
guard scope == ticket, model.activeID == documentID, doc.id == documentID else { throw AssemblyBuildFailure("access_denied") }
|
||||
if model.workspaceRevision != version {
|
||||
guard retry else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
return try await snapshot(model, ticket: ticket, retry: false)
|
||||
}
|
||||
guard try Self.sourcePaths(value) == files else { throw AssemblyBuildFailure("Shared files changed. Export a new connection.") }
|
||||
if last != value || lastSourceRevision != model.sourceRevision {
|
||||
lastSourceRevision = model.sourceRevision
|
||||
revision += 1; last = value; canRun = false; run = nil; runMessage = "No run started."
|
||||
appliedFiles = nil
|
||||
if let p = proposal { proposals[p.id]?["status"] = "stale"; proposal = nil }
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
private func reply(_ data: Data, ticket: UUID) async -> Data {
|
||||
func pack(_ value: [String: Any]) -> Data { (try? JSONSerialization.data(withJSONObject: value)) ?? Data(#"{"error":"encoding_error"}"#.utf8) }
|
||||
guard connected, ticket == scope, let model, model.activeID == documentID,
|
||||
let request = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
|
||||
let supplied = request["token"] as? String, supplied == token else { return pack(["error": "access_denied"]) }
|
||||
guard request["version"] as? Int == 1, let args = request["arguments"] as? [String: Any],
|
||||
let tool = request["tool"] as? String else { return pack(["error": "invalid_arguments"]) }
|
||||
func currentGrant() -> Bool {
|
||||
connected && scope == ticket && self.model === model && model.activeID == documentID
|
||||
}
|
||||
if tool == "search_help" || tool == "read_topic" {
|
||||
let reply = await MCPHelpIndex.toolResult(tool, arguments: args)
|
||||
guard currentGrant() else { return pack(["error": "access_denied"]) }
|
||||
return pack(reply)
|
||||
}
|
||||
do {
|
||||
let result = try await perform(tool, args, model: model, ticket: ticket)
|
||||
guard currentGrant() else { return pack(["error": "access_denied"]) }
|
||||
return pack(["result": result])
|
||||
} catch { return pack(["error": currentGrant() ? error.localizedDescription : "access_denied"]) }
|
||||
}
|
||||
|
||||
private func perform(_ tool: String, _ args: [String: Any], model: AssemblyDevelopmentModel, ticket: UUID) async throws -> [String: Any] {
|
||||
let snapshot = try await snapshot(model, ticket: ticket)
|
||||
guard connected, scope == ticket, self.model === model, model.activeID == documentID else { throw AssemblyBuildFailure("access_denied") }
|
||||
let id = model.activeID.uuidString
|
||||
if tool == "get_capabilities", args.isEmpty {
|
||||
return ["version": 1, "input_diagnostics": true, "kind": "assembly", "language": "assembly", "session_id": scope.uuidString,
|
||||
"project_id": id, "revision": revision, "entry": snapshot.mainPath, "target": snapshot.cpu.rawValue,
|
||||
"files": files.sorted(), "tools": Self.tools]
|
||||
}
|
||||
if tool == "get_machine_status", args.isEmpty {
|
||||
let observed = await model.machine.mcpReadinessSnapshot()
|
||||
var build = await MCPMachineStatus.missingToolBlockers(in: model.service.tools.toolchain, requiring: ["lwasm"])
|
||||
var run: [String] = []
|
||||
if requests.count >= 64 { build.append("Reconnect to start another build.") }
|
||||
if buildTask != nil || model.working || model.commanding { build.append("Wait for the current build or editor command.") }
|
||||
if !canRun || built?.artifact.snapshot != snapshot { run.append("Assemble the current project revision.") }
|
||||
if proposal != nil { run.append("Review the pending assembly edit.") }
|
||||
if model.machine.busy || model.working || model.commanding { run.append("Wait for the current machine or editor operation.") }
|
||||
return MCPMachineStatus.result(observed, workspace: .assembly(needs6309: snapshot.cpu == .hd6309),
|
||||
buildBlockers: build, runBlockers: run, lastBuild: latestBuildID.flatMap(buildRecord),
|
||||
profile: model.machine.usageProfile, input: model.machine.inputDiagnostics(machine: observed))
|
||||
}
|
||||
if tool == "get_build" {
|
||||
guard args.count == 1, let key = args["build_id"] as? String else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
guard let record = buildRecord(key) else { throw AssemblyBuildFailure("unknown_build") }
|
||||
return record
|
||||
}
|
||||
if tool == "get_proposal" {
|
||||
guard args.count == 1, let key = args["proposal_id"] as? String else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
guard let record = proposals[key] else { throw AssemblyBuildFailure("unknown_proposal") }
|
||||
return record
|
||||
}
|
||||
if tool == "read_screen_text" || tool == "send_keys" {
|
||||
guard let run, let built, let runIO, run.revision == revision, run.build == built.id,
|
||||
model.artifact?.id == built.artifact.id else { throw AssemblyBuildFailure("stale_run") }
|
||||
let epoch = model.workspaceRevision
|
||||
let result = try await runIO.reply(tool, arguments: args)
|
||||
guard connected, scope == ticket, self.runIO === runIO, model.activeID == documentID,
|
||||
model.workspaceRevision == epoch, revision == run.revision,
|
||||
model.artifact?.id == built.artifact.id else { throw AssemblyBuildFailure("stale_run") }
|
||||
return result
|
||||
}
|
||||
if tool == "get_debug_snapshot" || tool == "read_debug_memory" {
|
||||
guard let run, let built, run.id == args["run_id"] as? String, run.revision == revision,
|
||||
run.build == built.id, model.artifact?.id == built.artifact.id else { throw AssemblyBuildFailure("stale_run") }
|
||||
if tool == "get_debug_snapshot" {
|
||||
guard args.count == 1 else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
return try await runResult(model, ticket: ticket, inspect: true)
|
||||
}
|
||||
let epoch = model.workspaceRevision
|
||||
let now = await model.machine.mcpMachineSnapshot()
|
||||
guard scope == ticket, self.run?.id == run.id, model.activeID == documentID, model.workspaceRevision == epoch,
|
||||
revision == run.revision, model.artifact?.id == built.artifact.id,
|
||||
now.debuggerAssemblyAttached, MCPDebuggerInspection.sameProgram(now, run.machine),
|
||||
let inspection else { throw AssemblyBuildFailure("stale_snapshot") }
|
||||
return try inspection.reply(tool: tool, arguments: args)
|
||||
}
|
||||
guard args["project_id"] as? String == id else { throw AssemblyBuildFailure("access_denied") }
|
||||
if tool == "read_project_file" {
|
||||
guard args.count == 2, let path = args["path"] as? String, files.contains(path), let data = snapshot.files[path] else {
|
||||
throw AssemblyBuildFailure("path_not_shared")
|
||||
}
|
||||
return ["project_id": id, "revision": revision, "path": path, "text": String(decoding: data, as: UTF8.self)]
|
||||
}
|
||||
guard let requestedRevision = integer(args["revision"]) else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
if tool == "get_run", args.count == 2 {
|
||||
guard requestedRevision == revision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
return try await runResult(model, ticket: ticket)
|
||||
}
|
||||
guard ["build_project", "propose_fix", "propose_project_edits"].contains(tool) else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
guard let requestID = args["request_id"] as? String, (1...(tool == "propose_project_edits" ? 128 : 64)).contains(requestID.utf8.count)
|
||||
else { throw AssemblyBuildFailure("invalid_request_id") }
|
||||
if tool == "propose_fix", integer(args["line_number"]) == nil { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
if let previous = requests[requestID] {
|
||||
guard previous.tool == tool, previous.args.isEqual(to: args) else { throw AssemblyBuildFailure("request_conflict") }
|
||||
if let record = buildRecord(previous.id) ?? proposals[previous.id] { return record }
|
||||
}
|
||||
guard requestedRevision == revision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
guard requests.count < 64 else { throw AssemblyBuildFailure("session_request_limit") }
|
||||
let key = UUID().uuidString
|
||||
if tool == "build_project", args.count == 3 {
|
||||
guard buildTask == nil, !model.working, !model.commanding else { throw AssemblyBuildFailure("build_busy") }
|
||||
let number = revision, workspaceRevision = model.workspaceRevision
|
||||
let record: [String: Any] = ["build_id": key, "project_id": id, "revision": number, "status": "building", "diagnostics": []]
|
||||
latestBuildID = key
|
||||
builds[key] = record; requests[requestID] = (tool, NSDictionary(dictionary: args), key)
|
||||
built = nil; run = nil; canRun = false; runMessage = "No run started."
|
||||
buildTask = Task { [weak self] in
|
||||
await self?.build(model, inputs: snapshot, revision: number, id: key, ticket: ticket, workspaceRevision: workspaceRevision)
|
||||
}
|
||||
return record
|
||||
}
|
||||
if tool == "propose_project_edits" {
|
||||
guard args.count == 4, proposal == nil else { throw AssemblyBuildFailure("invalid_proposal") }
|
||||
let edits = try Self.projectEdits(args["edits"], snapshot: snapshot, shared: files)
|
||||
let record: [String: Any] = ["proposal_id": key, "revision": revision, "status": "pending",
|
||||
"kind": "project_edits", "files": edits.map(\.path)]
|
||||
proposals[key] = record; requests[requestID] = (tool, NSDictionary(dictionary: args), key)
|
||||
proposal = Proposal(id: key, revision: revision, content: .files(edits))
|
||||
status = "Review the proposed assembly files."
|
||||
if let window {
|
||||
window.makeKeyAndOrderFront(nil)
|
||||
if !NSApp.isActive { NSApp.requestUserAttention(.informationalRequest) }
|
||||
}
|
||||
return record
|
||||
}
|
||||
guard tool == "propose_fix", args.count == 6, proposal == nil, let path = args["path"] as? String, files.contains(path),
|
||||
let line = args["line_number"] as? Int, line > 0, let replacement = args["replacement"] as? String,
|
||||
replacement.utf8.count <= 1024, !replacement.contains(where: { $0.isNewline || $0 == "\0" }),
|
||||
let data = snapshot.files[path] else { throw AssemblyBuildFailure("invalid_proposal") }
|
||||
let source = String(decoding: data, as: UTF8.self)
|
||||
guard let range = Self.contentRange(line, source), range.length <= 4096 else { throw AssemblyBuildFailure("invalid_line") }
|
||||
let before = (source as NSString).substring(with: range)
|
||||
guard before != replacement else { throw AssemblyBuildFailure("unchanged_line") }
|
||||
let growth = replacement.utf8.count - before.utf8.count
|
||||
guard data.count + growth <= 64 * 1024,
|
||||
snapshot.files.values.reduce(0, { $0 + $1.count }) + growth <= 512 * 1024 else {
|
||||
throw AssemblyBuildFailure("project_too_large")
|
||||
}
|
||||
let record: [String: Any] = ["proposal_id": key, "revision": revision, "path": path, "line_number": line, "status": "pending"]
|
||||
proposals[key] = record; requests[requestID] = (tool, NSDictionary(dictionary: args), key)
|
||||
proposal = Proposal(id: key, revision: revision, content: .line(path: path, number: line, before: before, after: replacement))
|
||||
status = "Review the proposed assembly change."
|
||||
return record
|
||||
}
|
||||
|
||||
static func projectEdits(_ value: Any?, snapshot: AssemblyProjectSnapshot, shared: Set<String>) throws -> [AssemblyProjectEdit] {
|
||||
guard let rows = value as? [[String: Any]], (1...8).contains(rows.count) else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
var paths = Set<String>(), edits: [AssemblyProjectEdit] = []
|
||||
var bytes = 0, total = snapshot.files.values.reduce(0) { $0 + $1.count }
|
||||
for row in rows {
|
||||
guard row.count == 2, let path = row["path"] as? String, let source = row["source"] as? String,
|
||||
paths.insert(path).inserted, !source.utf8.contains(0) else { throw AssemblyBuildFailure("invalid_arguments") }
|
||||
guard shared.contains(path), let data = snapshot.files[path], let before = String(data: data, encoding: .utf8) else {
|
||||
throw AssemblyBuildFailure("access_denied")
|
||||
}
|
||||
guard !source.utf8.elementsEqual(before.utf8) else { throw AssemblyBuildFailure("unchanged_file") }
|
||||
let size = source.utf8.count
|
||||
bytes += size; total += size - data.count
|
||||
guard bytes <= 16 * 1024 else { throw AssemblyBuildFailure("patch_too_large") }
|
||||
edits.append(AssemblyProjectEdit(path: path, before: before, after: source))
|
||||
}
|
||||
guard total <= 512 * 1024 else { throw AssemblyBuildFailure("project_too_large") }
|
||||
return edits.sorted { $0.path < $1.path }
|
||||
}
|
||||
|
||||
private func integer(_ value: Any?) -> Int? {
|
||||
guard let n = value as? NSNumber, CFGetTypeID(n) != CFBooleanGetTypeID(),
|
||||
!["f", "d"].contains(String(cString: n.objCType)) else { return nil }
|
||||
return Int(exactly: n)
|
||||
}
|
||||
|
||||
private func buildRecord(_ id: String) -> [String: Any]? {
|
||||
guard var record = builds[id] else { return nil }
|
||||
if record["revision"] as? Int != revision { record["status"] = "stale" }
|
||||
return record
|
||||
}
|
||||
|
||||
private func build(_ model: AssemblyDevelopmentModel, inputs: AssemblyProjectSnapshot, revision number: Int,
|
||||
id: String, ticket: UUID, workspaceRevision: UUID) async {
|
||||
defer { if ticket == scope { buildTask = nil } }
|
||||
do {
|
||||
let artifact = try await model.service.build(inputs)
|
||||
guard try await snapshot(model, ticket: ticket) == inputs, revision == number, ticket == scope,
|
||||
workspaceRevision == model.workspaceRevision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
builds[id]?["status"] = "succeeded"
|
||||
builds[id]?["entry"] = Int(artifact.entry)
|
||||
builds[id]?["target"] = inputs.cpu.rawValue
|
||||
builds[id]?["instruction_count"] = artifact.instructions.count
|
||||
builds[id]?["ranges"] = artifact.ranges.map { [Int($0.lowerBound), Int($0.upperBound)] }
|
||||
built = (id, number, artifact); canRun = true
|
||||
model.acceptSharedBuild(artifact)
|
||||
status = "Assembled for " + inputs.cpu.rawValue + ". " + AssemblyDevelopmentModel.summary(artifact)
|
||||
} catch {
|
||||
guard scope == ticket else { return }
|
||||
builds[id]?["status"] = revision == number ? "failed" : "stale"
|
||||
builds[id]?["diagnostics"] = (error as? AssemblyBuildFailure)?.diagnostics.prefix(32).map {
|
||||
["path": $0.path, "line": $0.line, "message": String($0.message.prefix(512))] as [String: Any]
|
||||
} ?? []
|
||||
builds[id]?["message"] = String(error.localizedDescription.prefix(2048))
|
||||
status = String(error.localizedDescription.prefix(512))
|
||||
}
|
||||
}
|
||||
|
||||
private static func contentRange(_ line: Int, _ source: String) -> NSRange? {
|
||||
let text = source as NSString
|
||||
guard let span = AssemblyDevelopmentModel.lineRange(line, text: source), span.location < text.length else { return nil }
|
||||
var end = 0
|
||||
text.getLineStart(nil, end: nil, contentsEnd: &end, for: NSRange(location: span.location, length: 0))
|
||||
return NSRange(location: span.location, length: end - span.location)
|
||||
}
|
||||
|
||||
func decide(_ id: String, apply: Bool) async {
|
||||
guard let p = proposal, p.id == id, let model else { return }
|
||||
if !apply { proposals[p.id]?["status"] = "cancelled"; proposal = nil; return }
|
||||
do {
|
||||
let value = try await snapshot(model, ticket: scope)
|
||||
guard proposal?.id == p.id, revision == p.revision, !model.working, !model.commanding else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
guard connected, model.activeID == documentID, model.sourceRevision == lastSourceRevision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
if case let .files(edits) = p.content {
|
||||
let removed = try replaceFiles(edits, model: model, value: value)
|
||||
appliedFiles = AppliedFiles(proposal: p, revision: revision, removedStops: removed)
|
||||
proposal = nil; proposals[p.id]?["status"] = "applied"; proposals[p.id]?["applied_revision"] = revision
|
||||
status = "Applied all reviewed files to the assembly draft."
|
||||
return
|
||||
}
|
||||
guard case let .line(path, line, before, after) = p.content else { return }
|
||||
guard model.buffer.path == path, value.files[path] == Data(model.buffer.text.utf8) else {
|
||||
model.selectFile(path, line: line)
|
||||
status = "Review the selected source file, then apply the change."
|
||||
return
|
||||
}
|
||||
guard let range = Self.contentRange(line, model.buffer.text), (model.buffer.text as NSString).substring(with: range) == before else {
|
||||
throw AssemblyBuildFailure("revision_conflict")
|
||||
}
|
||||
let expected = (model.buffer.text as NSString).replacingCharacters(in: range, with: after)
|
||||
let accepted = editors?.replaceReviewedLine(in: model.buffer, range: range, with: after) ?? false
|
||||
guard accepted, model.buffer.text == expected else { throw AssemblyBuildFailure("Open the assembly editor before applying the proposal.") }
|
||||
proposal = nil; proposals[p.id]?["status"] = "applied"
|
||||
_ = try await snapshot(model, ticket: scope)
|
||||
proposals[p.id]?["applied_revision"] = revision
|
||||
status = "Applied the edit. Build the revised assembly source."
|
||||
} catch { status = error.localizedDescription }
|
||||
}
|
||||
|
||||
private func replaceFiles(_ edits: [AssemblyProjectEdit], model: AssemblyDevelopmentModel, value: AssemblyProjectSnapshot,
|
||||
undo: Bool = false, restore: Set<AssemblyDevelopmentModel.SourceLine> = []) throws -> Set<AssemblyDevelopmentModel.SourceLine> {
|
||||
let paths = Set(edits.map(\.path))
|
||||
guard editors?.canReplace(model.document.buffers.filter { paths.contains($0.path) }) != false else {
|
||||
throw AssemblyBuildFailure("Finish the current editor input before applying this review.")
|
||||
}
|
||||
let removed = try model.replaceReviewedFiles(edits, snapshot: value, undo: undo, restoreStops: restore)
|
||||
var files = value.files
|
||||
for edit in edits { files[edit.path] = Data((undo ? edit.before : edit.after).utf8) }
|
||||
last = AssemblyProjectSnapshot(mainPath: value.mainPath, files: files, cpu: value.cpu, settings: value.settings)
|
||||
lastSourceRevision = model.sourceRevision; revision += 1
|
||||
built = nil; canRun = false; run = nil; runMessage = "No run started."
|
||||
return removed
|
||||
}
|
||||
|
||||
func undoFiles(_ id: String) async {
|
||||
guard let applied = appliedFiles, applied.proposal.id == id, let model, case let .files(edits) = applied.proposal.content else { return }
|
||||
do {
|
||||
let value = try await snapshot(model, ticket: scope)
|
||||
guard connected, model.activeID == documentID, appliedFiles?.proposal.id == applied.proposal.id, proposal == nil,
|
||||
revision == applied.revision, model.sourceRevision == lastSourceRevision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
_ = try replaceFiles(edits, model: model, value: value, undo: true, restore: applied.removedStops)
|
||||
proposals[applied.proposal.id]?["status"] = "undone"; appliedFiles = nil
|
||||
status = "Undid all reviewed assembly changes."
|
||||
} catch { status = error.localizedDescription }
|
||||
}
|
||||
|
||||
func startRun(_ id: String, confirm: ((String) -> Bool)? = nil) async {
|
||||
guard canRun, proposal == nil, let model, let built, built.id == id, !model.working, !model.commanding else { return }
|
||||
let ticket = scope
|
||||
do {
|
||||
guard try await snapshot(model, ticket: ticket) == built.artifact.snapshot, self.built?.id == built.id,
|
||||
proposal == nil, revision == built.revision else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
run = nil; runMessage = "Starting"
|
||||
let launched = try await model.launchShared(built.artifact, stillGranted: { [weak self] in
|
||||
self?.scope == ticket && self?.built?.id == built.id && self?.revision == built.revision &&
|
||||
self?.proposal == nil && self?.model?.activeID == self?.documentID
|
||||
}, confirm: confirm)
|
||||
guard scope == ticket else { return }
|
||||
let runID = UUID().uuidString
|
||||
run = (runID, built.revision, built.id, launched)
|
||||
runIO = MCPCompiledRunIO(machine: model.machine, runID: runID, expected: launched, assembly: true)
|
||||
runMessage = "started"; status = "Assembly program loaded."
|
||||
} catch { if scope == ticket { runMessage = error.localizedDescription; status = runMessage } }
|
||||
}
|
||||
|
||||
private func runResult(_ model: AssemblyDevelopmentModel, ticket: UUID, inspect: Bool = false) async throws -> [String: Any] {
|
||||
guard let run, let built, run.revision == revision, run.build == built.id else {
|
||||
return ["status": runMessage, "revision": revision]
|
||||
}
|
||||
let workspaceRevision = model.workspaceRevision
|
||||
let capture: VCCDebuggerSnapshot? = await withCheckedContinuation { c in
|
||||
model.machine.readDebugger(address: 0, followPC: true, memoryAddress: 0x0400) { c.resume(returning: $0) }
|
||||
}
|
||||
guard let capture, scope == ticket, revision == run.revision, self.run?.id == run.id,
|
||||
model.activeID == documentID, workspaceRevision == model.workspaceRevision,
|
||||
model.artifact?.id == built.artifact.id else { throw AssemblyBuildFailure("stale_run") }
|
||||
let current = capture.machine
|
||||
guard current.generation == run.machine.generation, current.debuggerProgramRevision == run.machine.debuggerProgramRevision,
|
||||
current.debuggerMappingFingerprint == run.machine.debuggerMappingFingerprint, current.debuggerAssemblyAttached
|
||||
else { throw AssemblyBuildFailure("stale_run") }
|
||||
var result: [String: Any] = ["run_id": run.id, "build_id": built.id, "revision": revision, "target": built.artifact.snapshot.cpu.rawValue,
|
||||
"processor": current.use6309 ? "HD6309" : "MC6809", "status": current.state == .paused ? "paused" : "running"]
|
||||
if current.assistantCompiledReturned {
|
||||
if inspect { throw AssemblyBuildFailure("run_finished") }
|
||||
result["status"] = "finished"
|
||||
if let runIO {
|
||||
if let text = try await runIO.finalScreenText() { result["final_screen_text"] = text }
|
||||
guard scope == ticket, self.runIO === runIO, self.run?.id == run.id,
|
||||
model.activeID == documentID, workspaceRevision == model.workspaceRevision else {
|
||||
throw AssemblyBuildFailure("stale_run")
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
guard current.state == .paused else {
|
||||
if inspect { throw AssemblyBuildFailure("pause_required") }
|
||||
return result
|
||||
}
|
||||
let guards = AssemblyDevelopmentModel.codeGuards(built.artifact.instructions)
|
||||
for (address, bytes) in guards {
|
||||
let range = Int(address)..<(Int(address) + bytes.count)
|
||||
guard range.upperBound <= capture.logicalMemory.count, range.upperBound <= capture.logicalMemoryAvailable.count,
|
||||
capture.logicalMemoryAvailable[range].allSatisfy({ $0 != 0 }), capture.logicalMemory[range].elementsEqual(bytes)
|
||||
else { throw AssemblyBuildFailure("stale_run") }
|
||||
}
|
||||
let pc = current.programCounter
|
||||
let candidates = built.artifact.instructions.filter { $0.address == pc }
|
||||
var sourceStop: [String: Any]?
|
||||
if candidates.count == 1, let mapped = candidates.first, files.contains(mapped.path),
|
||||
AssemblyDevelopmentModel.location(.init(path: mapped.path, line: mapped.line), in: built.artifact) != nil,
|
||||
let instruction = capture.instructions.first, instruction.address == pc, Array(instruction.bytes) == mapped.bytes {
|
||||
sourceStop = ["path": mapped.path, "line": mapped.line, "address": Int(pc), "instruction_bytes": mapped.bytes.map(Int.init)]
|
||||
}
|
||||
if inspect {
|
||||
var ranges = built.artifact.instructions.filter { files.contains($0.path) && guards[$0.address] != nil }.map {
|
||||
Int($0.address)..<(Int($0.address) + $0.bytes.count)
|
||||
}
|
||||
ranges.append(0x0400..<0x0401)
|
||||
let snapshot = try MCPDebuggerInspection(runID: run.id, capture: capture,
|
||||
scope: ["project_id": model.activeID.uuidString, "build_id": built.id, "revision": revision],
|
||||
sourceStop: sourceStop, watches: [], watchStatus: "Assembly has no source-level variable watches.", ranges: ranges)
|
||||
inspection = snapshot
|
||||
return snapshot.fields
|
||||
}
|
||||
guard let sourceStop else { return result }
|
||||
result["source_stop"] = sourceStop
|
||||
var registers = ["pc": Int(pc)]
|
||||
if let a = capture.registers["A"] { registers["a"] = a.intValue }
|
||||
if let e = capture.registers["E"] { registers["e"] = e.intValue }
|
||||
result["registers"] = registers
|
||||
if capture.logicalMemoryAvailable.count > 0x0400, capture.logicalMemoryAvailable[0x0400] != 0 {
|
||||
result["text_ram_0400"] = Int(capture.logicalMemory[0x0400])
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
#if DEBUG
|
||||
/// A fresh, explicitly isolated synthetic project. Only the regression variant accepts test decisions.
|
||||
func startFixture(_ model: AssemblyDevelopmentModel, directory: URL, romDirectory: URL) async throws {
|
||||
guard CommandLine.arguments.contains("--interface-validation"),
|
||||
try FileManager.default.contentsOfDirectory(atPath: directory.path).isEmpty
|
||||
else { throw AssemblyBuildFailure("Use an empty isolated assembly validation directory.") }
|
||||
try await MCPBASICRun.bootFixture(model.machine, romDirectory: romDirectory)
|
||||
let project = directory.appendingPathComponent("Assembly")
|
||||
try FileManager.default.createDirectory(at: project, withIntermediateDirectories: false)
|
||||
let enhanced = CommandLine.arguments.contains("--mcp-assembly-hd6309")
|
||||
let source = """
|
||||
org $3f00
|
||||
include "value.inc"
|
||||
start \(enhanced ? "lde" : "lda") #VALUE
|
||||
\(enhanced ? "adde" : "adda") #1
|
||||
\(enhanced ? "ste" : "sta") $0400
|
||||
done rts
|
||||
end start
|
||||
|
||||
"""
|
||||
try Data(source.utf8).write(to: project.appendingPathComponent("main.asm"), options: .withoutOverwriting)
|
||||
try Data("VALUE equ 1\n".utf8).write(to: project.appendingPathComponent("value.inc"), options: .withoutOverwriting)
|
||||
model.open(project, folder: true)
|
||||
let deadline = ContinuousClock.now.advanced(by: .seconds(3))
|
||||
while model.document.directory?.lastPathComponent != project.lastPathComponent, ContinuousClock.now < deadline {
|
||||
try await Task.sleep(for: .milliseconds(30))
|
||||
}
|
||||
let physicalProject = try CMOCProject.physicalURL(project)
|
||||
guard model.document.directory?.path == physicalProject.path else { throw AssemblyBuildFailure("The synthetic assembly workspace failed to open.") }
|
||||
model.setCPU(enhanced ? .hd6309 : .mc6809)
|
||||
try await connect(model, to: directory.appendingPathComponent("grant.json"))
|
||||
guard CommandLine.arguments.contains("--mcp-assembly-regression") else { return }
|
||||
let editorPool = AssemblyEditorPool()
|
||||
editors = editorPool
|
||||
let editorWindow = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 620, height: 320),
|
||||
styleMask: [.titled], backing: .buffered, defer: false)
|
||||
editorWindow.title = "Assembly Development — Regression"
|
||||
let editor = NSHostingView(rootView: AssemblyEditor(finder: SourceFind(), model: model, pool: editorPool, lookup: {}))
|
||||
editor.sizingOptions = []
|
||||
editorWindow.contentView = editor
|
||||
editorWindow.orderBack(nil)
|
||||
editor.layoutSubtreeIfNeeded()
|
||||
try Data().write(to: directory.appendingPathComponent("assembly-regression-fixture"), options: .withoutOverwriting)
|
||||
let ticket = scope
|
||||
Task {
|
||||
defer { editorWindow.orderOut(nil) }
|
||||
func consume(_ name: String) -> Bool { unlink(directory.appendingPathComponent(name).path) == 0 }
|
||||
while scope == ticket {
|
||||
try? await Task.sleep(for: .milliseconds(100))
|
||||
if consume("apply"), let id = proposal?.id { await decide(id, apply: true) }
|
||||
if consume("undo-files"), let id = undoableProposalID { await undoFiles(id) }
|
||||
if consume("cancel-project-edits"), let id = proposal?.id { await decide(id, apply: false) }
|
||||
if consume("stale-review-click") {
|
||||
// A click captured from a retired native review must never operate on its replacement.
|
||||
await decide("retired-review", apply: true)
|
||||
await decide("retired-review", apply: false)
|
||||
await undoFiles("retired-review")
|
||||
try? Data().write(to: directory.appendingPathComponent("checked-stale-click"))
|
||||
}
|
||||
if consume("capture-review"), proposal != nil {
|
||||
show(model, editors: editorPool)
|
||||
try? await Task.sleep(for: .milliseconds(250))
|
||||
if let panel = window {
|
||||
let capture = Process()
|
||||
capture.executableURL = URL(fileURLWithPath: "/usr/sbin/screencapture")
|
||||
capture.arguments = ["-x", "-o", "-l", String(panel.windowNumber), directory.appendingPathComponent("review.png").path]
|
||||
capture.terminationHandler = { _ in Task { @MainActor in panel.orderOut(nil) } }
|
||||
do { try capture.run() } catch { panel.orderOut(nil) }
|
||||
}
|
||||
}
|
||||
if consume("stale-run-click") {
|
||||
await startRun("retired-build", confirm: { _ in true })
|
||||
try? Data().write(to: directory.appendingPathComponent("checked-stale-run"))
|
||||
}
|
||||
if consume("play"), let id = runnableBuildID { await startRun(id, confirm: { _ in true }) }
|
||||
if consume("run"), let id = runnableBuildID {
|
||||
if !model.document.breakpoints.contains(.init(path: "main.asm", line: 6)),
|
||||
let span = AssemblyDevelopmentModel.lineRange(6, text: model.buffer.text) {
|
||||
model.moveCursor(span.location); model.toggleBreakpoint()
|
||||
}
|
||||
await startRun(id, confirm: { _ in true })
|
||||
}
|
||||
if consume("quit") {
|
||||
revoke()
|
||||
NSApp.perform(#selector(NSApplication.terminate(_:)), with: nil, afterDelay: 0)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
private struct AssemblyAccessView: View {
|
||||
@ObservedObject var access: MCPAssembly
|
||||
@ObservedObject var model: AssemblyDevelopmentModel
|
||||
@State private var expandedFiles = Set<String>()
|
||||
var body: some View {
|
||||
ScrollView {
|
||||
VStack(alignment: .leading, spacing: 10) {
|
||||
Label(model.document.title, systemImage: "cpu").font(.headline)
|
||||
if access.connected {
|
||||
if let proposal = access.proposal {
|
||||
switch proposal.content {
|
||||
case let .line(path, number, before, after):
|
||||
Text("\(path), line \(number)").bold()
|
||||
comparison(before: before, after: after)
|
||||
reviewButtons(proposal.id, multiple: false)
|
||||
case .files(let edits):
|
||||
Text(edits.count == 1 ? "Review 1 assembly file" : "Review \(edits.count) assembly files").font(.headline)
|
||||
reviewButtons(proposal.id, multiple: true)
|
||||
ForEach(edits, id: \.path) { edit in
|
||||
DisclosureGroup(edit.path, isExpanded: Binding(
|
||||
get: { expandedFiles.contains(edit.path) },
|
||||
set: { if $0 { expandedFiles.insert(edit.path) } else { expandedFiles.remove(edit.path) } }
|
||||
)) {
|
||||
HStack(alignment: .top, spacing: 12) {
|
||||
sourceColumn("Current", edit.before)
|
||||
Divider()
|
||||
sourceColumn("Proposed", edit.after)
|
||||
}.padding(.vertical, 4)
|
||||
}
|
||||
}
|
||||
.onAppear { if let first = edits.first { expandedFiles = [first.path] } }
|
||||
.id(proposal.id)
|
||||
}
|
||||
}
|
||||
if let id = access.undoableProposalID {
|
||||
Button("Undo All Changes") { Task { await access.undoFiles(id) } }
|
||||
}
|
||||
if let url = access.grantURL {
|
||||
MCPChatGPTSetup(grantURL: url, firstPrompt: "Identify my shared VCC Plus assembly project and target processor. Read the entry source file and describe what the CoCo program does.")
|
||||
}
|
||||
HStack {
|
||||
Button("Copy MCP Helper Path") {
|
||||
NSPasteboard.general.clearContents()
|
||||
NSPasteboard.general.setString(Bundle.main.bundleURL.appendingPathComponent("Contents/Helpers/vcc-mcp").path, forType: .string)
|
||||
}
|
||||
Button("Revoke Connection") { access.revoke() }
|
||||
}
|
||||
let buildID = access.runnableBuildID
|
||||
Button("Run Shared Build…") {
|
||||
if let buildID { Task { await access.startRun(buildID) } }
|
||||
}.disabled(buildID == nil || access.proposal != nil || model.commanding || model.working)
|
||||
} else {
|
||||
Text("Share this document’s assembly files with a client that can build them and propose edits. You approve edits and start runs. The client can read the guest text screen and send one letter, digit or space at a time during your run. It can check machine and media status. At a verified source stop it can inspect registers, shared program memory and the text byte at $0400. The client’s model provider may receive those results.")
|
||||
Button("Save Assembly Connection…") { access.choose(model) }
|
||||
}
|
||||
if !access.status.isEmpty { Text(access.status).foregroundStyle(.secondary).textSelection(.enabled) }
|
||||
}.padding().frame(maxWidth: .infinity, alignment: .leading)
|
||||
}
|
||||
}
|
||||
private func sourceColumn(_ title: String, _ source: String) -> some View {
|
||||
VStack(alignment: .leading, spacing: 4) {
|
||||
Text(title).font(.caption).foregroundStyle(.secondary)
|
||||
ScrollView(.horizontal) {
|
||||
Text(verbatim: source).font(.callout.monospaced()).textSelection(.enabled)
|
||||
.fixedSize(horizontal: true, vertical: true)
|
||||
}
|
||||
}.frame(maxWidth: .infinity, alignment: .leading)
|
||||
}
|
||||
@ViewBuilder private func comparison(before: String, after: String) -> some View {
|
||||
Text("Current").font(.caption)
|
||||
Text(before).font(.body.monospaced()).textSelection(.enabled)
|
||||
Text("Proposed").font(.caption)
|
||||
Text(after).font(.body.monospaced()).textSelection(.enabled)
|
||||
}
|
||||
private func reviewButtons(_ id: String, multiple: Bool) -> some View {
|
||||
HStack {
|
||||
Button(multiple ? "Apply All Changes" : "Apply Edit") { Task { await access.decide(id, apply: true) } }
|
||||
Button(multiple ? "Cancel Changes" : "Cancel Edit") { Task { await access.decide(id, apply: false) } }
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user