@lattices/cli 0.4.9 → 0.4.11

package/swift/Sources/DeckKit/DeckTrackpad.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+public struct DeckTrackpadState: Codable, Equatable, Sendable {
+    public var isEnabled: Bool
+    public var isAvailable: Bool
+    public var statusTitle: String
+    public var statusDetail: String?
+    public var pointerScale: Double
+    public var scrollScale: Double
+    public var supportsDragLock: Bool
+
+    public init(
+        isEnabled: Bool,
+        isAvailable: Bool,
+        statusTitle: String,
+        statusDetail: String? = nil,
+        pointerScale: Double = 1.6,
+        scrollScale: Double = 1.0,
+        supportsDragLock: Bool = true
+    ) {
+        self.isEnabled = isEnabled
+        self.isAvailable = isAvailable
+        self.statusTitle = statusTitle
+        self.statusDetail = statusDetail
+        self.pointerScale = pointerScale
+        self.scrollScale = scrollScale
+        self.supportsDragLock = supportsDragLock
+    }
+}
+
+public struct DeckTrackpadEventRequest: Codable, Equatable, Sendable {
+    public var event: DeckTrackpadEvent
+    public var dx: Double
+    public var dy: Double
+
+    public init(
+        event: DeckTrackpadEvent,
+        dx: Double = 0,
+        dy: Double = 0
+    ) {
+        self.event = event
+        self.dx = dx
+        self.dy = dy
+    }
+}
+
+public enum DeckTrackpadEvent: String, Codable, CaseIterable, Sendable {
+    case move
+    case click
+    case rightClick
+    case scroll
+    case mouseDown
+    case mouseUp
+    case drag
+}
+
+public struct DeckTrackpadEventResult: Codable, Equatable, Sendable {
+    public var ok: Bool
+
+    public init(ok: Bool) {
+        self.ok = ok
+    }
+}

package/swift/Sources/DeckKit/DeckValue.swift

@@ -0,0 +1,93 @@
+import Foundation
+
+public enum DeckValue: Codable, Equatable, Sendable {
+    case string(String)
+    case int(Int)
+    case double(Double)
+    case bool(Bool)
+    case array([DeckValue])
+    case object([String: DeckValue])
+    case null
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if container.decodeNil() {
+            self = .null
+        } else if let bool = try? container.decode(Bool.self) {
+            self = .bool(bool)
+        } else if let int = try? container.decode(Int.self) {
+            self = .int(int)
+        } else if let double = try? container.decode(Double.self) {
+            self = .double(double)
+        } else if let string = try? container.decode(String.self) {
+            self = .string(string)
+        } else if let array = try? container.decode([DeckValue].self) {
+            self = .array(array)
+        } else if let object = try? container.decode([String: DeckValue].self) {
+            self = .object(object)
+        } else {
+            throw DecodingError.dataCorruptedError(
+                in: container,
+                debugDescription: "Unsupported DeckValue payload"
+            )
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case .string(let value):
+            try container.encode(value)
+        case .int(let value):
+            try container.encode(value)
+        case .double(let value):
+            try container.encode(value)
+        case .bool(let value):
+            try container.encode(value)
+        case .array(let value):
+            try container.encode(value)
+        case .object(let value):
+            try container.encode(value)
+        case .null:
+            try container.encodeNil()
+        }
+    }
+
+    public var stringValue: String? {
+        guard case .string(let value) = self else { return nil }
+        return value
+    }
+
+    public var intValue: Int? {
+        guard case .int(let value) = self else { return nil }
+        return value
+    }
+
+    public var doubleValue: Double? {
+        switch self {
+        case .double(let value):
+            return value
+        case .int(let value):
+            return Double(value)
+        default:
+            return nil
+        }
+    }
+
+    public var boolValue: Bool? {
+        guard case .bool(let value) = self else { return nil }
+        return value
+    }
+
+    public var arrayValue: [DeckValue]? {
+        guard case .array(let value) = self else { return nil }
+        return value
+    }
+
+    public var objectValue: [String: DeckValue]? {
+        guard case .object(let value) = self else { return nil }
+        return value
+    }
+}

package/swift/Sources/DeckKit/DeckVoiceError.swift

@@ -0,0 +1,88 @@
+import Foundation
+
+// MARK: - Voice error model
+//
+// Shared across Mac (capture + execution) and iPad (relay + status).
+// Stable raw string values so codes survive JSON, JSONL logs, and the bridge
+// snapshot. See `docs/voice-error-model.md` for the design rationale.
+
+public struct DeckVoiceError: Codable, Equatable, Identifiable, Sendable {
+    public var id: String
+    public var code: DeckVoiceErrorCode
+    public var severity: DeckErrorSeverity
+    public var recoverable: Bool
+    public var retry: DeckRetryHint?
+    public var source: DeckErrorSource
+    public var owner: String?                  // e.g. "Vox" for mic_busy
+    public var message: String                 // cockpit copy, human-readable
+    public var remediation: DeckRemediationAction?
+    public var occurredAt: Date
+    public var detail: String?                 // diagnostic-only, not displayed
+
+    public init(
+        id: String = UUID().uuidString,
+        code: DeckVoiceErrorCode,
+        severity: DeckErrorSeverity,
+        recoverable: Bool,
+        retry: DeckRetryHint? = nil,
+        source: DeckErrorSource,
+        owner: String? = nil,
+        message: String,
+        remediation: DeckRemediationAction? = nil,
+        occurredAt: Date = .now,
+        detail: String? = nil
+    ) {
+        self.id = id
+        self.code = code
+        self.severity = severity
+        self.recoverable = recoverable
+        self.retry = retry
+        self.source = source
+        self.owner = owner
+        self.message = message
+        self.remediation = remediation
+        self.occurredAt = occurredAt
+        self.detail = detail
+    }
+}
+
+public enum DeckVoiceErrorCode: String, Codable, CaseIterable, Sendable {
+    case voxUnreachable      = "vox_unreachable"
+    case daemonUnreachable   = "daemon_unreachable"
+    case network             = "network"
+    case connectionLost      = "connection_lost"
+    case micDenied           = "mic_denied"
+    case accessibilityDenied = "accessibility_denied"
+    case micBusy             = "mic_busy"
+    case noActiveTarget      = "no_active_target"
+    case voxNotRunning       = "vox_not_running"
+    case voxLoading          = "vox_loading"
+    case intentUnresolved    = "intent_unresolved"
+    case actionFailed        = "action_failed"
+    case transcriptionFailed = "transcription_failed"
+    case emptyTranscript     = "empty_transcript"
+    case languageUnsupported = "language_unsupported"
+}
+
+public enum DeckErrorSeverity: String, Codable, CaseIterable, Sendable {
+    case info, warning, error, blocked
+}
+
+public enum DeckRetryHint: String, Codable, CaseIterable, Sendable {
+    case silent                      // reconnect quietly, log only
+    case immediate                   // safe to auto-retry now
+    case afterLaunch  = "after_launch"  // retry after launching a dependency (e.g. Vox)
+    case userAction   = "user_action"   // user must do something first
+}
+
+public enum DeckErrorSource: String, Codable, CaseIterable, Sendable {
+    case mac, ipad, vox, daemon, intent, bridge
+}
+
+public enum DeckRemediationAction: Codable, Equatable, Sendable {
+    case openVox
+    case openSystemSettings(kind: String)
+    case retryVoice
+    case openDiagnostics
+    case chooseTarget
+}

package/swift/Tests/DeckKitTests/DeckKitTests.swift

@@ -0,0 +1,286 @@
+import XCTest
+@testable import DeckKit
+
+final class DeckKitTests: XCTestCase {
+    func testManifestRoundTripPreservesEmbeddedSecurity() throws {
+        let manifest = DeckManifest(
+            product: DeckProductIdentity(
+                id: "com.arach.lattices",
+                displayName: "Lattices Companion",
+                owner: "lattices"
+            ),
+            security: .embeddedDelegated(owner: "talkie"),
+            capabilities: [.voiceAgent, .layoutControl, .embeddedSecurityDelegation],
+            pages: [
+                DeckPage(
+                    id: "voice",
+                    title: "Voice",
+                    iconSystemName: "mic.fill",
+                    kind: .voice,
+                    accentToken: "royal-blue"
+                )
+            ]
+        )
+
+        let data = try JSONEncoder().encode(manifest)
+        let decoded = try JSONDecoder().decode(DeckManifest.self, from: data)
+
+        XCTAssertEqual(decoded, manifest)
+        XCTAssertEqual(decoded.security.delegatedOwner, "talkie")
+    }
+
+    func testSecurityConvenienceProfilesMatchIntendedModes() {
+        let standalone = DeckSecurityConfiguration.standaloneBonjour()
+        XCTAssertEqual(standalone.mode, .standalone)
+        XCTAssertEqual(standalone.pairingStrategy, .bonjour)
+        XCTAssertTrue(standalone.requestSigningRequired)
+        XCTAssertTrue(standalone.payloadEncryptionRequired)
+        XCTAssertNil(standalone.delegatedOwner)
+
+        let embedded = DeckSecurityConfiguration.embeddedDelegated(owner: "talkie")
+        XCTAssertEqual(embedded.mode, .embedded)
+        XCTAssertEqual(embedded.pairingStrategy, .delegated)
+        XCTAssertTrue(embedded.payloadEncryptionRequired)
+        XCTAssertEqual(embedded.delegatedOwner, "talkie")
+    }
+
+    func testPairingPayloadRoundTripPreservesSecurityFlags() throws {
+        let response = DeckPairingResponse(
+            disposition: .approved,
+            bridgeName: "Lats Bridge",
+            bridgePublicKey: "bridge-public-key",
+            bridgeFingerprint: "ABCD-1234",
+            requestSigningRequired: true,
+            payloadEncryptionRequired: true,
+            grantedCapabilities: [
+                DeckBridgeCapability.deckRead,
+                DeckBridgeCapability.deckPerform,
+            ],
+            detail: "Trusted on the Mac."
+        )
+
+        let data = try JSONEncoder().encode(response)
+        let decoded = try JSONDecoder().decode(DeckPairingResponse.self, from: data)
+
+        XCTAssertEqual(decoded, response)
+        XCTAssertEqual(decoded.grantedCapabilities, [
+            DeckBridgeCapability.deckRead,
+            DeckBridgeCapability.deckPerform,
+        ])
+    }
+
+    func testPairingPayloadDecodesLegacyCapabilityDefaults() throws {
+        let responseJSON = """
+        {
+          "disposition": "approved",
+          "bridgeName": "Lats Bridge",
+          "bridgePublicKey": "bridge-public-key",
+          "bridgeFingerprint": "ABCD-1234",
+          "requestSigningRequired": true,
+          "payloadEncryptionRequired": true
+        }
+        """.data(using: .utf8)!
+
+        let decodedResponse = try JSONDecoder().decode(DeckPairingResponse.self, from: responseJSON)
+        XCTAssertEqual(decodedResponse.grantedCapabilities, DeckBridgeCapability.defaultCompanionCapabilities)
+
+        let requestJSON = """
+        {
+          "deviceID": "ipad-1",
+          "deviceName": "iPad",
+          "devicePublicKey": "device-public-key",
+          "platform": "iPadOS"
+        }
+        """.data(using: .utf8)!
+
+        let decodedRequest = try JSONDecoder().decode(DeckPairingRequest.self, from: requestJSON)
+        XCTAssertEqual(decodedRequest.requestedCapabilities, DeckBridgeCapability.defaultCompanionCapabilities)
+    }
+
+    func testRuntimeSnapshotRoundTripPreservesSwitcherAndHistory() throws {
+        let snapshot = DeckRuntimeSnapshot(
+            updatedAt: Date(timeIntervalSince1970: 1_713_700_000),
+            cockpit: DeckCockpitState(
+                title: "Command Deck",
+                detail: "Quick controls from your Mac-defined cockpit.",
+                pages: [
+                    DeckCockpitPage(
+                        id: "main",
+                        title: "Main",
+                        subtitle: "Core controls",
+                        columns: 4,
+                        tiles: [
+                            DeckCockpitTile(
+                                id: "main-0",
+                                shortcutID: "voice-toggle",
+                                title: "Voice",
+                                subtitle: "Start listening",
+                                iconSystemName: "mic.fill",
+                                accentToken: "voice",
+                                actionID: "voice.toggle",
+                                isActive: true
+                            )
+                        ]
+                    )
+                ]
+            ),
+            trackpad: DeckTrackpadState(
+                isEnabled: true,
+                isAvailable: true,
+                statusTitle: "Trackpad Ready",
+                statusDetail: "Use the surface to move the Mac pointer.",
+                pointerScale: 1.8,
+                scrollScale: 1.2,
+                supportsDragLock: true
+            ),
+            voice: DeckVoiceState(
+                phase: .reasoning,
+                transcript: "Arrange my review setup",
+                transcriptLines: [
+                    DeckTranscriptLine(
+                        id: "line-1",
+                        createdAt: Date(timeIntervalSince1970: 1_713_700_001),
+                        text: "Arrange my review setup",
+                        isFinal: true,
+                        confidence: 0.93,
+                        source: "vox"
+                    )
+                ],
+                responseSummary: "Preparing a code review layout.",
+                provider: "vox"
+            ),
+            desktop: DeckDesktopSummary(
+                activeLayerName: "review",
+                activeAppName: "Safari",
+                screenCount: 2,
+                visibleWindowCount: 6,
+                sessionCount: 3
+            ),
+            layout: DeckLayoutState(
+                screenName: "Built-in Retina Display",
+                frontmostWindow: DeckLayoutFocusWindow(
+                    id: "window:42",
+                    itemID: "window:42",
+                    appName: "Safari",
+                    title: "Pull request",
+                    frame: DeckRect(x: 40, y: 80, w: 1440, h: 900),
+                    normalizedFrame: DeckRect(x: 0.0, y: 0.0, w: 0.75, h: 1.0),
+                    placement: "left"
+                ),
+                preview: DeckLayoutPreview(
+                    aspectRatio: 1.6,
+                    windows: [
+                        DeckLayoutPreviewWindow(
+                            id: "window:42",
+                            itemID: "window:42",
+                            title: "Pull request",
+                            subtitle: "Safari",
+                            normalizedFrame: DeckRect(x: 0.0, y: 0.0, w: 0.75, h: 1.0),
+                            appCategory: "browser",
+                            appCategoryTint: "blue",
+                            isFrontmost: true
+                        )
+                    ]
+                )
+            ),
+            switcher: DeckSwitcherState(items: [
+                DeckSwitcherItem(
+                    id: "app:safari",
+                    title: "Safari",
+                    subtitle: "Pull request",
+                    iconToken: "safari",
+                    kind: .application,
+                    isFrontmost: true
+                ),
+                DeckSwitcherItem(
+                    id: "session:frontend-a1b2c3",
+                    title: "frontend-a1b2c3",
+                    subtitle: "tmux session",
+                    iconToken: "terminal",
+                    kind: .session
+                )
+            ]),
+            telemetry: DeckSystemTelemetry(
+                sampledAt: Date(timeIntervalSince1970: 1_713_700_002),
+                cpuLoadPercent: 31,
+                memoryUsedPercent: 68,
+                gpuLoadPercent: 12,
+                thermalPressurePercent: 10,
+                thermalState: .nominal,
+                batteryPercent: 84,
+                isCharging: true,
+                powerSource: "AC Power",
+                windowCount: 6,
+                sessionCount: 3
+            ),
+            spaces: DeckSpacesState(
+                currentSpaceIndex: 2,
+                currentSpaceName: "code",
+                displays: [
+                    DeckSpaceDisplay(
+                        id: "main",
+                        displayIndex: 0,
+                        currentSpaceID: 20,
+                        currentSpaceIndex: 2,
+                        currentSpaceName: "code",
+                        spaces: [
+                            DeckSpace(id: 10, index: 1, name: "main", isCurrent: false),
+                            DeckSpace(id: 20, index: 2, name: "code", isCurrent: true)
+                        ]
+                    )
+                ]
+            ),
+            cockpitMode: DeckCockpitModeState(
+                mode: .replay,
+                replayMessage: "Placed Safari left",
+                replayUndoActionID: "history.undoLast"
+            ),
+            activityLog: [
+                DeckActivityLogEntry(
+                    id: "activity-1",
+                    tag: "DECK",
+                    tint: "blue",
+                    text: "Placed Safari left"
+                )
+            ],
+            history: [
+                DeckHistoryEntry(
+                    id: "history-1",
+                    title: "Grid layout applied",
+                    detail: "Distributed four visible windows.",
+                    kind: .layout,
+                    undoActionID: "undo-grid-layout"
+                )
+            ],
+            questions: [
+                DeckQuestionCard(
+                    id: "question-1",
+                    prompt: "Which monitor should hold the terminals?",
+                    options: [
+                        DeckQuestionOption(
+                            id: "primary",
+                            title: "Primary display",
+                            actionID: "layout.place-terminals-primary"
+                        )
+                    ]
+                )
+            ]
+        )
+
+        let data = try JSONEncoder().encode(snapshot)
+        let decoded = try JSONDecoder().decode(DeckRuntimeSnapshot.self, from: data)
+
+        XCTAssertEqual(decoded, snapshot)
+        XCTAssertEqual(decoded.cockpit?.pages.first?.tiles.first?.shortcutID, "voice-toggle")
+        XCTAssertEqual(decoded.trackpad?.statusTitle, "Trackpad Ready")
+        XCTAssertEqual(decoded.voice?.provider, "vox")
+        XCTAssertEqual(decoded.voice?.transcriptLines?.first?.source, "vox")
+        XCTAssertEqual(decoded.layout?.frontmostWindow?.placement, "left")
+        XCTAssertEqual(decoded.layout?.preview?.windows.first?.appCategoryTint, "blue")
+        XCTAssertEqual(decoded.switcher?.items.count, 2)
+        XCTAssertEqual(decoded.telemetry?.thermalState, .nominal)
+        XCTAssertEqual(decoded.spaces?.currentSpaceName, "code")
+        XCTAssertEqual(decoded.cockpitMode?.mode, .replay)
+        XCTAssertEqual(decoded.activityLog?.first?.tag, "DECK")
+    }
+}