Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

fix(macos): refresh open detail after device approval (#4794)

injaneity59e372ec6b29
diff --git a/apps/cua-spaces-macos/Sources/CuaSpacesMacKit/Views/SpaceDetailView.swift b/apps/cua-spaces-macos/Sources/CuaSpacesMacKit/Views/SpaceDetailView.swift
index 3e78b689be..89416e2e26 100644
--- a/apps/cua-spaces-macos/Sources/CuaSpacesMacKit/Views/SpaceDetailView.swift
+++ b/apps/cua-spaces-macos/Sources/CuaSpacesMacKit/Views/SpaceDetailView.swift
@@ -37,6 +37,7 @@ struct SpaceDetailView: View {
var body: some View {
let detail = model.detail(space)
+ let wantsStream = model.cover(detail, requested: connectRequested, stream: .noSession).openStream
ScrollViewReader { scroller in
Form {
if let note = detail.desktopNote {
@@ -87,8 +88,9 @@ struct SpaceDetailView: View {
.navigationTitle(detail.title)
.toolbar { toolbar(detail) }
// A delete stops the stream, its pop-outs and the polling at once
- // (and a failed one starts them again).
- .task(id: "\(live) \(connectRequested)") { await connect(detail) }
+ // (and a failed one starts them again). Approval also re-evaluates
+ // the core's eligibility without reopening this detail.
+ .task(id: "\(live) \(wantsStream)") { await connect(detail) }
// The cover's preview: the shared store's image at once, then one
// no older than the background interval.
.task(id: live) {
@@ -313,6 +315,7 @@ struct SpaceDetailView: View {
model.cover(detail, requested: connectRequested, stream: .noSession).openStream else { return }
do {
let provider = try await model.backend.streamProvider(id: space.id)
+ guard !Task.isCancelled else { return }
self.provider = provider
let session = LiveStreamSession(provider: provider)
self.session = session
@@ -325,6 +328,7 @@ struct SpaceDetailView: View {
if let first = session.windows.first { pips.popOut(.window(first)) }
}
} catch {
+ guard !Task.isCancelled else { return }
model.show(error: "Could not open \(space.name): \(LiveSpacesBackend.words(error))")
}
}
diff --git a/apps/cua-spaces-macos/Tests/CuaSpacesMacTests/DetailApprovalTests.swift b/apps/cua-spaces-macos/Tests/CuaSpacesMacTests/DetailApprovalTests.swift
new file mode 100644
index 0000000000..1364f29dc5
--- /dev/null
+++ b/apps/cua-spaces-macos/Tests/CuaSpacesMacTests/DetailApprovalTests.swift
@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: FSL-1.1-MIT
+// Copyright (c) 2026 Cua AI, Inc.
+
+import CuaSDK
+import CuaSpacesFFI
+import CuaSpacesStreaming
+@testable import CuaSpacesMacKit
+import Foundation
+import AppKit
+import Testing
+import SwiftUI
+
+/// Scripted provider completions; no service, account, or desktop is contacted.
+private final class ApprovalBackend: SpacesBackend, @unchecked Sendable {
+ var result: Result<[AppSpaceRow], Error> = .success(FixtureSpacesBackend.sample)
+ var failFirst = false
+ var holdFirst = false
+ private var held: CheckedContinuation<Void, Never>?
+ func release() { lock.withLock { held?.resume(); held = nil } }
+ private let lock = NSLock()
+ private var ids: [String] = []
+ var requestedIds: [String] { lock.withLock { ids } }
+ var isHeld: Bool { lock.withLock { held != nil } }
+ func rows() async throws -> [AppSpaceRow] { try result.get() }
+ func create(_ args: AppCreateSpaceArgs, createId: String, progress: @escaping @Sendable (SpaceCreateProgress) -> Void) async throws -> String { fatalError("unexpected create") }
+ func cancelCreate(createId: String) async throws {}
+ func add(url: String, token: String?, name: String?) async throws {}
+ func remove(id: String, removeOnly: Bool) async throws {}
+ func setPower(id: String, on: Bool) async throws {}
+ func streamProvider(id: String) async throws -> SpaceStreamSourceProviding {
+ let attempt = lock.withLock { ids.append(id); return ids.count }
+ if holdFirst && attempt == 1 {
+ await withCheckedContinuation { continuation in lock.withLock { held = continuation } }
+ }
+ if failFirst && attempt == 1 { throw CuaError.Internal(message: "cancelled provider result") }
+ return try await FixtureSpacesBackend().streamProvider(id: id)
+ }
+ func localBackends() async -> [String]? { nil }
+ func localStorage() async -> LocalStorage? { nil }
+ func cloudAvailable() async -> Bool { false }
+ func teleportContext(id: String) async throws -> (CuaSpacesFFI.Teleport, CuaSDK.Space)? { nil }
+ func teleportHandle() -> CuaSpacesFFI.Teleport? { nil }
+ func sendFiles(id: String, paths: [String]) async throws -> [AppSentFileInfo] { [] }
+ func agentRuns(id: String) async throws -> [AppSpaceAgentRun] { [] }
+}
+
+@MainActor
+@Suite("Detail approval refresh", .serialized)
+struct DetailApprovalTests {
+ @MainActor private struct Fixture {
+ let backend: ApprovalBackend
+ let devices: FixtureDevices
+ let model: AppModel
+ let space: AppSpace
+ let window: NSWindow
+ let directory: URL
+
+ func close() {
+ backend.release()
+ window.contentView = nil
+ window.close()
+ try? FileManager.default.removeItem(at: directory)
+ }
+
+ func setApproved(_ approved: Bool) async {
+ devices.current.devices[0].state = approved ? "enrolled" : "pending"
+ await model.devices.refresh()
+ window.contentView?.layoutSubtreeIfNeeded()
+ }
+
+ func waitForRequests(_ count: Int) async throws {
+ for _ in 0..<40 where backend.requestedIds.count < count {
+ try await Task.sleep(for: .milliseconds(50))
+ }
+ if count == 1 && backend.holdFirst {
+ for _ in 0..<40 where !backend.isHeld { try await Task.sleep(for: .milliseconds(50)) }
+ #expect(backend.isHeld)
+ }
+ #expect(backend.requestedIds == Array(repeating: space.id, count: count))
+ }
+ }
+
+ private func open(autoConnect: Bool, holdFirst: Bool = false, failFirst: Bool = false) async throws -> Fixture {
+ let backend = ApprovalBackend()
+ backend.holdFirst = holdFirst
+ backend.failFirst = failFirst
+ var row = FixtureSpacesBackend.sample[0]
+ row.id = "relay:studio"
+ row.provider = "relay"
+ backend.result = .success([row])
+ var snapshot = FixtureDevices.sample(now: UInt64(Date().timeIntervalSince1970))
+ snapshot.devices[0].state = "pending"
+ let devices = FixtureDevices(snapshot: snapshot)
+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+ let model = AppModel(backend: backend, keyvault: KeyvaultModel(client: nil),
+ onboarding: OnboardingModel(statePath: nil),
+ settingsPath: directory.appendingPathComponent("settings.json").path,
+ telemetry: FixtureTelemetry(), devices: devices, presence: FixturePresence())
+ model.settings.autoConnect = autoConnect
+ await model.refresh()
+ model.devices.signedIn = true
+ await model.devices.refresh()
+ let space = try #require(model.spaces.first { $0.id == row.id })
+ #expect(model.detail(space).access != nil)
+ let host = NSHostingView(rootView: SpaceDetailView(model: model, space: space)
+ .frame(width: 800, height: 800))
+ let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 800, height: 800),
+ styleMask: [.borderless], backing: .buffered, defer: false)
+ window.isReleasedWhenClosed = false
+ window.contentView = host
+ host.layoutSubtreeIfNeeded()
+ try await Task.sleep(for: .milliseconds(250))
+ #expect(backend.requestedIds.isEmpty)
+ return Fixture(backend: backend, devices: devices, model: model, space: space,
+ window: window, directory: directory)
+ }
+
+ @Test(arguments: [false, true])
+ func approvalReevaluatesTheSameDetail(autoConnect: Bool) async throws {
+ let f = try await open(autoConnect: autoConnect)
+ defer { f.close() }
+ await f.setApproved(true)
+ #expect(f.model.detail(f.space).access == nil)
+ if autoConnect { try await f.waitForRequests(1) }
+ // Repeated device snapshots neither force a manual connection nor
+ // restart a connection that was already created for this exact ID.
+ await f.setApproved(true)
+ await f.setApproved(true)
+ try await Task.sleep(for: .milliseconds(250))
+ #expect(f.backend.requestedIds == (autoConnect ? [f.space.id] : []))
+ }
+
+ @Test(arguments: [false, true])
+ func cancelledProviderCannotBlockLaterApproval(failFirst: Bool) async throws {
+ let f = try await open(autoConnect: true, holdFirst: true, failFirst: failFirst)
+ defer { f.close() }
+ await f.setApproved(true)
+ try await f.waitForRequests(1)
+ await f.setApproved(false)
+ try await Task.sleep(for: .milliseconds(100))
+ // The backend deliberately returns even though its caller was
+ // cancelled. Its old provider must not be installed in this view.
+ f.backend.release()
+ try await Task.sleep(for: .milliseconds(100))
+ #expect(f.model.banner == nil)
+ await f.setApproved(true)
+ try await f.waitForRequests(2)
+ }
+}