@lattices/cli 0.4.8 → 0.4.10

package/app/Lattices.app/Contents/Info.plist

@@ -26,9 +26,9 @@
         </dict>
     </array>
     <key>CFBundleVersion</key>
-    <string>0.4.8</string>
+    <string>0.4.10</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.4.8</string>
+    <string>0.4.10</string>
     <key>LSMinimumSystemVersion</key>
     <string>13.0</string>
     <key>LSUIElement</key>

package/app/Sources/AppShell/AppDelegate.swift

@@ -194,6 +194,10 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
         AgentPool.shared.start()
         diag.finish(tBoot)
 
+        Task {
+            await AppUpdater.shared.checkIfNeeded()
+        }
+
         // --diagnostics flag: auto-open diagnostics panel on launch
         if CommandLine.arguments.contains("--diagnostics") {
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {

package/app/Sources/AppShell/AppUpdater.swift

@@ -1,6 +1,15 @@
 import AppKit
 import Combine
 import Foundation
+import SwiftUI
+
+struct LatticesUpdateInfo: Equatable {
+    let version: String
+    let downloadURL: URL
+    let releaseNotes: String
+    let publishedAt: Date
+    let htmlURL: URL
+}
 
 @MainActor
 final class AppUpdater: ObservableObject {
@@ -8,6 +17,16 @@ final class AppUpdater: ObservableObject {
 
     @Published private(set) var isUpdating = false
     @Published private(set) var statusMessage: String?
+    @Published private(set) var availableUpdate: LatticesUpdateInfo?
+    @Published private(set) var isChecking = false
+    @Published private(set) var lastChecked: Date?
+    @Published private(set) var lastError: String?
+
+    @AppStorage("appUpdater.autoCheck") var autoCheckEnabled = true
+    @AppStorage("appUpdater.lastCheckTime") private var lastCheckTimeInterval: Double = 0
+    @AppStorage("appUpdater.skippedVersion") private var skippedVersion = ""
+
+    private let checkInterval: TimeInterval = 24 * 60 * 60
 
     private init() {}
 
@@ -27,6 +46,62 @@ final class AppUpdater: ObservableObject {
         return nil
     }
 
+    func checkIfNeeded() async {
+        guard autoCheckEnabled else { return }
+
+        let now = Date()
+        let lastCheck = Date(timeIntervalSince1970: lastCheckTimeInterval)
+        if now.timeIntervalSince(lastCheck) < checkInterval { return }
+
+        await check()
+    }
+
+    func check() async {
+        guard !isChecking else { return }
+
+        isChecking = true
+        lastError = nil
+
+        defer {
+            isChecking = false
+            lastChecked = Date()
+            lastCheckTimeInterval = Date().timeIntervalSince1970
+        }
+
+        do {
+            let release = try await fetchLatestRelease()
+            guard let update = parseRelease(release), isNewerVersion(update.version) else {
+                availableUpdate = nil
+                return
+            }
+
+            if update.version == skippedVersion {
+                availableUpdate = nil
+                return
+            }
+
+            availableUpdate = update
+        } catch UpdateCheckError.noRelease {
+            availableUpdate = nil
+        } catch {
+            lastError = error.localizedDescription
+        }
+    }
+
+    func skipCurrentUpdate() {
+        guard let update = availableUpdate else { return }
+        skippedVersion = update.version
+        availableUpdate = nil
+    }
+
+    func viewCurrentRelease() {
+        if let update = availableUpdate {
+            NSWorkspace.shared.open(update.htmlURL)
+        } else if let url = URL(string: "https://github.com/arach/lattices/releases/latest") {
+            NSWorkspace.shared.open(url)
+        }
+    }
+
     func promptForUpdate() {
         guard canUpdate else {
             presentAlert(
@@ -36,11 +111,50 @@ final class AppUpdater: ObservableObject {
             return
         }
 
+        guard availableUpdate != nil else {
+            Task {
+                await check()
+                if availableUpdate != nil {
+                    presentUpdateConfirmation()
+                } else if let error = lastError {
+                    presentAlert(
+                        title: "Could Not Check for Updates",
+                        message: error
+                    )
+                } else {
+                    presentAlert(
+                        title: "Lattices Is Up to Date",
+                        message: "You’re running \(currentVersion), which is the latest published release."
+                    )
+                }
+            }
+            return
+        }
+
+        presentUpdateConfirmation()
+    }
+
+    private func presentUpdateConfirmation() {
         let alert = NSAlert()
         alert.alertStyle = .informational
-        alert.messageText = "Install the latest Lattices app update?"
-        alert.informativeText = "Lattices will download the latest released app bundle, close, and relaunch when the update is ready."
-        alert.addButton(withTitle: "Update")
+        if let update = availableUpdate {
+            alert.messageText = "Update Lattices?"
+            alert.informativeText = """
+            Current version: \(currentVersion)
+            New version: \(update.version)
+
+            Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.
+            """
+        } else {
+            alert.messageText = "Check and update Lattices?"
+            alert.informativeText = """
+            Current version: \(currentVersion)
+            New version: latest published release
+
+            Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.
+            """
+        }
+        alert.addButton(withTitle: availableUpdate == nil ? "Check & Update" : "Update")
         alert.addButton(withTitle: "Cancel")
 
         guard alert.runModal() == .alertFirstButtonReturn else { return }
@@ -72,7 +186,11 @@ final class AppUpdater: ObservableObject {
         do {
             try proc.run()
             isUpdating = true
-            statusMessage = "Updating to the latest release. Lattices will relaunch when it's ready."
+            if let update = availableUpdate {
+                statusMessage = "Preparing Lattices \(update.version). The app will relaunch when the update is ready."
+            } else {
+                statusMessage = "Preparing the latest Lattices release. The app will relaunch when the update is ready."
+            }
         } catch {
             presentAlert(
                 title: "Update Failed",
@@ -89,4 +207,98 @@ final class AppUpdater: ObservableObject {
         alert.addButton(withTitle: "OK")
         alert.runModal()
     }
+
+    private func fetchLatestRelease() async throws -> GitHubRelease {
+        let url = URL(string: "https://api.github.com/repos/arach/lattices/releases/latest")!
+        var request = URLRequest(url: url)
+        request.setValue("application/vnd.github+json", forHTTPHeaderField: "Accept")
+        request.setValue("Lattices/\(currentVersion)", forHTTPHeaderField: "User-Agent")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+        guard let http = response as? HTTPURLResponse else {
+            throw UpdateCheckError.invalidResponse
+        }
+
+        switch http.statusCode {
+        case 200:
+            let decoder = JSONDecoder()
+            decoder.keyDecodingStrategy = .convertFromSnakeCase
+            decoder.dateDecodingStrategy = .iso8601
+            return try decoder.decode(GitHubRelease.self, from: data)
+        case 404:
+            throw UpdateCheckError.noRelease
+        case 403:
+            throw UpdateCheckError.rateLimited
+        default:
+            throw UpdateCheckError.httpError(http.statusCode)
+        }
+    }
+
+    private func parseRelease(_ release: GitHubRelease) -> LatticesUpdateInfo? {
+        guard !release.draft, !release.prerelease else { return nil }
+
+        let asset = release.assets.first { asset in
+            asset.name == "Lattices.dmg" ||
+            (asset.name.hasPrefix("Lattices") && asset.name.hasSuffix(".dmg"))
+        }
+
+        guard let asset,
+              let downloadURL = URL(string: asset.browserDownloadUrl),
+              let htmlURL = URL(string: release.htmlUrl) else {
+            return nil
+        }
+
+        let version = release.tagName.hasPrefix("v")
+            ? String(release.tagName.dropFirst())
+            : release.tagName
+
+        return LatticesUpdateInfo(
+            version: version,
+            downloadURL: downloadURL,
+            releaseNotes: release.body ?? "",
+            publishedAt: release.publishedAt,
+            htmlURL: htmlURL
+        )
+    }
+
+    private func isNewerVersion(_ remoteVersion: String) -> Bool {
+        guard currentVersion != "unknown" else { return false }
+        return remoteVersion.compare(currentVersion, options: .numeric) == .orderedDescending
+    }
+}
+
+private struct GitHubRelease: Decodable {
+    let tagName: String
+    let name: String
+    let body: String?
+    let htmlUrl: String
+    let publishedAt: Date
+    let assets: [GitHubAsset]
+    let prerelease: Bool
+    let draft: Bool
+}
+
+private struct GitHubAsset: Decodable {
+    let name: String
+    let browserDownloadUrl: String
+}
+
+private enum UpdateCheckError: LocalizedError {
+    case invalidResponse
+    case noRelease
+    case rateLimited
+    case httpError(Int)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from GitHub."
+        case .noRelease:
+            return "No published release found."
+        case .rateLimited:
+            return "GitHub rate limited the update check."
+        case .httpError(let code):
+            return "GitHub returned HTTP \(code)."
+        }
+    }
 }

package/app/Sources/AppShell/SettingsView.swift

@@ -301,15 +301,53 @@ struct SettingsContentView: View {
                                 .font(Typo.mono(12))
                                 .foregroundColor(Palette.text)
                             Spacer()
-                            Text("v\(appUpdater.currentVersion)")
+                            Text("Current v\(appUpdater.currentVersion)")
                                 .font(Typo.caption(10))
                                 .foregroundColor(Palette.textMuted)
                         }
 
-                        Text("Install the latest published app build without leaving the menu bar. The app relaunches when the update finishes.")
+                        Text("Lattices can check for new signed releases and prepare the update here. You’ll confirm before the app quits and relaunches.")
                             .font(Typo.caption(10))
                             .foregroundColor(Palette.textMuted)
 
+                        if let update = appUpdater.availableUpdate {
+                            VStack(alignment: .leading, spacing: 6) {
+                                HStack(spacing: 6) {
+                                    Image(systemName: "gift.fill")
+                                        .font(.system(size: 10, weight: .semibold))
+                                        .foregroundColor(Palette.detach)
+                                    Text("New version v\(update.version) is ready")
+                                        .font(Typo.monoBold(10))
+                                        .foregroundColor(Palette.detach)
+                                }
+
+                                if !update.releaseNotes.isEmpty {
+                                    Text(String(update.releaseNotes.prefix(180)) + (update.releaseNotes.count > 180 ? "..." : ""))
+                                        .font(Typo.caption(9))
+                                        .foregroundColor(Palette.textMuted)
+                                        .lineLimit(3)
+                                }
+                            }
+                            .padding(8)
+                            .background(
+                                RoundedRectangle(cornerRadius: 5)
+                                    .fill(Palette.surfaceHov.opacity(0.65))
+                                    .overlay(RoundedRectangle(cornerRadius: 5).strokeBorder(Palette.detach.opacity(0.35), lineWidth: 0.5))
+                            )
+                        } else if appUpdater.isChecking {
+                            Text("Checking for updates...")
+                                .font(Typo.caption(9))
+                                .foregroundColor(Palette.textMuted)
+                        } else if let error = appUpdater.lastError {
+                            Text(error)
+                                .font(Typo.caption(9))
+                                .foregroundColor(Palette.detach.opacity(0.9))
+                        } else if let checked = appUpdater.lastChecked {
+                            Text("Last checked \(checked, style: .relative)")
+                                .font(Typo.caption(9))
+                                .foregroundColor(Palette.textMuted.opacity(0.8))
+                        }
+
                         if let status = appUpdater.statusMessage {
                             Text(status)
                                 .font(Typo.caption(9))
@@ -326,7 +364,7 @@ struct SettingsContentView: View {
                             Button {
                                 appUpdater.promptForUpdate()
                             } label: {
-                                Text(appUpdater.isUpdating ? "Updating…" : "Update Lattices")
+                                Text(appUpdater.isUpdating ? "Preparing…" : (appUpdater.availableUpdate == nil ? "Check for Updates" : "Update to v\(appUpdater.availableUpdate?.version ?? "")"))
                                     .font(Typo.monoBold(10))
                                     .foregroundColor(Palette.text)
                                     .padding(.horizontal, 12)
@@ -340,6 +378,43 @@ struct SettingsContentView: View {
                             .buttonStyle(.plain)
                             .disabled(appUpdater.isUpdating)
 
+                            Button {
+                                Task { await appUpdater.check() }
+                            } label: {
+                                Text(appUpdater.isChecking ? "Checking..." : "Check Now")
+                                    .font(Typo.caption(9))
+                                    .foregroundColor(Palette.textMuted.opacity(0.9))
+                            }
+                            .buttonStyle(.plain)
+                            .disabled(appUpdater.isChecking)
+
+                            Toggle("Auto", isOn: $appUpdater.autoCheckEnabled)
+                                .font(Typo.caption(9))
+                                .toggleStyle(.checkbox)
+                                .foregroundColor(Palette.textMuted.opacity(0.9))
+
+                            if appUpdater.availableUpdate != nil {
+                                Button {
+                                    appUpdater.viewCurrentRelease()
+                                } label: {
+                                    Text("Release Notes")
+                                        .font(Typo.caption(9))
+                                        .foregroundColor(Palette.textMuted.opacity(0.9))
+                                }
+                                .buttonStyle(.plain)
+
+                                Button {
+                                    appUpdater.skipCurrentUpdate()
+                                } label: {
+                                    Text("Skip")
+                                        .font(Typo.caption(9))
+                                        .foregroundColor(Palette.textMuted.opacity(0.75))
+                                }
+                                .buttonStyle(.plain)
+                            }
+
+                            Spacer()
+
                             Text("CLI: `lattices app update`")
                                 .font(Typo.caption(9))
                                 .foregroundColor(Palette.textMuted.opacity(0.8))

package/app/Sources/Core/Desktop/DesktopModel.swift

@@ -43,6 +43,7 @@ final class DesktopModel: ObservableObject {
         "storeuid",
         // Third-party helpers
         "CursorUIViewService",
+        "Codex Computer Use",
         "Electron Helper",
         "Google Chrome Helper",
     ]

package/app/Sources/Core/Overlays/ScreenMap/ScreenMapState.swift

@@ -144,7 +144,7 @@ enum CanvasDragMode {
 
 final class ScreenMapEditorState: ObservableObject {
     @Published var windows: [ScreenMapWindowEntry]
-    @Published var selectedLayers: Set<Int> = [0]  // empty = show all
+    @Published var selectedLayers: Set<Int> = []  // empty = show all
     @Published var draggingWindowId: UInt32? = nil
     var canvasDragMode: CanvasDragMode = .move
     var currentCursorMode: CanvasDragMode = .move
@@ -153,7 +153,7 @@ final class ScreenMapEditorState: ObservableObject {
     @Published var zoomLevel: CGFloat = 1.0   // 1.0 = fit-all
     @Published var panOffset: CGPoint = .zero  // canvas-local pixels
     @Published var focusedDisplayIndex: Int? = nil  // nil = all-displays view
-    @Published var activeViewportPreset: ScreenMapViewportPreset? = .main
+    @Published var activeViewportPreset: ScreenMapViewportPreset? = .overview
     @Published var windowSearchQuery: String = ""
     @Published var isTilingMode: Bool = false
     var isSearching: Bool { !windowSearchQuery.isEmpty }
@@ -380,10 +380,11 @@ final class ScreenMapEditorState: ObservableObject {
         return "L\(layer)"
     }
 
-    /// Windows visible for the active layer filter
+    /// Windows visible on the current desktop for the active layer filter.
     var visibleWindows: [ScreenMapWindowEntry] {
-        guard !selectedLayers.isEmpty else { return windows }
-        return windows.filter { selectedLayers.contains($0.layer) }
+        let onscreen = windows.filter(\.isOnScreen)
+        guard !selectedLayers.isEmpty else { return onscreen }
+        return onscreen.filter { selectedLayers.contains($0.layer) }
     }
 
     private var worldScopedDisplays: [DisplayGeometry] {
@@ -398,7 +399,7 @@ final class ScreenMapEditorState: ObservableObject {
 
     var canvasWorldBounds: CGRect {
         var rects = worldScopedDisplays.map(\.cgRect)
-        rects.append(contentsOf: worldScopedWindows.map(\.virtualFrame))
+        rects.append(contentsOf: worldScopedWindows.filter(\.hasEdits).map(\.virtualFrame))
 
         if rects.isEmpty {
             return CGRect(origin: bboxOrigin, size: screenSize)
@@ -409,7 +410,7 @@ final class ScreenMapEditorState: ObservableObject {
             union = union.union(rect)
         }
 
-        let pad: CGFloat = focusedDisplayIndex == nil ? 120 : 80
+        let pad: CGFloat = focusedDisplayIndex == nil ? 180 : 120
         return union.insetBy(dx: -pad, dy: -pad)
     }
 
@@ -1424,7 +1425,7 @@ final class ScreenMapController: ObservableObject {
 
     private func finalizeDisplayFocusChange(flashLabel: Bool) {
         guard let ed = editor else { return }
-        focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
+        focusViewportPreset(ed.activeViewportPreset ?? .overview, flashView: false)
         if flashLabel {
             flash(ed.focusedDisplay?.label ?? "All displays")
         }
@@ -1454,6 +1455,7 @@ final class ScreenMapController: ObservableObject {
         guard newZoom != ed.zoomLevel else { return }
         ed.activeViewportPreset = nil
         ed.zoomLevel = newZoom
+        ed.scale = ed.fitScale * newZoom
         objectWillChange.send()
     }
 
@@ -1677,7 +1679,7 @@ final class ScreenMapController: ObservableObject {
     func enter() {
         let existingSets = windowSets
         guard let windowList = CGWindowListCopyWindowInfo(
-            [.optionAll, .excludeDesktopElements], kCGNullWindowID
+            [.optionOnScreenOnly, .excludeDesktopElements], kCGNullWindowID
         ) as? [[String: Any]] else { return }
 
         struct CGWin {
@@ -1724,7 +1726,7 @@ final class ScreenMapController: ObservableObject {
             guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { continue }
             guard rect.width >= 100 && rect.height >= 50 else { continue }
             let app = info[kCGWindowOwnerName as String] as? String ?? ""
-            if app == "Lattices" || app == "lattices" || app == "AutoFill" { continue }
+            if app == "Lattices" || app == "lattices" || app == "AutoFill" || app == "Codex Computer Use" { continue }
             let pid = info[kCGWindowOwnerPID as String] as? Int32 ?? 0
             let title = info[kCGWindowName as String] as? String ?? ""
             let dIdx = displayIndex(for: rect)
@@ -1844,15 +1846,14 @@ final class ScreenMapController: ObservableObject {
             }
         }
 
-        // Auto-focus the display where the mouse cursor is
-        if screens.count > 1 {
+        // Start monitor-first: focus the display under the cursor, or the first display.
+        if !displayGeometries.isEmpty {
             let mouseLocation = NSEvent.mouseLocation
             let mouseCG = CGPoint(x: mouseLocation.x, y: primaryHeight - mouseLocation.y)
-            for disp in displayGeometries {
-                if disp.cgRect.contains(mouseCG) {
-                    newEditor.focusedDisplayIndex = disp.index
-                    break
-                }
+            if let display = displayGeometries.first(where: { $0.cgRect.contains(mouseCG) }) {
+                newEditor.focusedDisplayIndex = display.index
+            } else {
+                newEditor.focusedDisplayIndex = displayGeometries[0].index
             }
         }
 
@@ -1867,7 +1868,12 @@ final class ScreenMapController: ObservableObject {
             self.activeWindowSetID = nil
         }
         selectedWindowIds = []
-        focusViewportPreset(.main, flashView: false)
+        focusViewportPreset(.overview, flashView: false)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.08) { [weak self] in
+            guard let self,
+                  self.editor?.activeViewportPreset == .overview else { return }
+            self.focusViewportPreset(.overview, flashView: false)
+        }
     }
 
     /// Re-snapshot, preserving display/layer context
@@ -1914,10 +1920,15 @@ final class ScreenMapController: ObservableObject {
         ed.activeViewportPreset = preset
         let rect = ed.viewportRect(for: preset)
         DiagnosticLog.shared.info("[Canvas] preset → \(preset.title)")
+        if preset == .overview {
+            ed.zoomLevel = 1
+            ed.scale = ed.fitScale
+            ed.panOffset = .zero
+        }
         queueCanvasNavigation(
             centeredOn: CGPoint(x: rect.midX, y: rect.midY),
             rect: rect,
-            zoomToFit: true
+            zoomToFit: preset != .overview
         )
         if flashView {
             flash(preset.title)
@@ -1960,6 +1971,14 @@ final class ScreenMapController: ObservableObject {
         }
 
         setViewport(centeredOn: target.center, zoomLevel: targetZoom)
+        if target.zoomToFit {
+            ed.pendingCanvasNavigation = ScreenMapCanvasNavigationTarget(
+                center: target.center,
+                rect: nil,
+                zoomToFit: false
+            )
+            ed.canvasNavigationRevision &+= 1
+        }
         if shouldLogView {
             let viewport = ed.viewportWorldRect
             DiagnosticLog.shared.info(