@lattices/cli 0.4.8 → 0.4.9

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

@@ -26,9 +26,9 @@
         </dict>
     </array>
     <key>CFBundleVersion</key>
-    <string>0.4.8</string>
+    <string>0.4.9</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.4.8</string>
+    <string>0.4.9</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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lattices/cli",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Agentic window manager for macOS — programmable workspace, smart layouts, managed tmux sessions, and a 35+-method agent API",
   "bin": {
     "lattices": "./bin/lattices.ts",