chore: release 26.1.7

- Simplified awk extraction without aggressive sed cleanup
- Now correctly extracts version-specific changelog entries
- Works with minimal or full changelog sections

.gitignore

@@ -5,3 +5,4 @@ build/
 Build/
 dist/
 .signing.env
+homebrew-tap/

CHANGELOG.md

@@ -1,10 +1,54 @@
 # Changelog
 
-## Unreleased
+## 26.1.7
+- Added remote reboot support for hosts running KeyHelp API 2.14 or newer.
+- Added a dedicated `APIv2_14` client and mapped 2.14+ hosts to it instead of treating them as API 2.13.
+- Fixed the reboot request to call `/api/v2/server/reboot` with the required JSON confirmation payload.
+- Changed the reboot confirmation and result UI to non-blocking sheets/banner feedback so failures no longer trap the app in modal dialogs.
+- Improved API error messages by surfacing the server response body instead of only generic HTTP status codes.
+- Reduced expected reboot noise by suppressing ping checks for a short grace period after a reboot request.
+
+## 26.1.6
+- Publish Gitea releases as stable by default instead of pre-releases.
+- Update the Homebrew tap automatically after each successful release by rewriting the cask version and DMG checksum, then pushing the tap repo.
+- Simplified the README for end users by adding clear install options and trimming internal release-engineering details.
+- Ignore the local `homebrew-tap/` checkout in the main app repository.
+
+## 26.1.3
+- Fixed version handling for changelogs.
+
+## 26.1.2 (2025-01-03)
+- Synced version.json to 26.1.2.
+
+## 26.1.1 (2025-01-03)
+- Fixed changelog extraction in publish script.
+
+## 26.1.0 (2025-01-03)
+- Auto-populate release description from CHANGELOG when publishing to Gitea.
+
+## Prereleases
+
+### Fixed
+- Fixed excessive refresh timer resets by properly cancelling previous subscriptions and validating value changes before recreating timers.
+- Fixed interval indicator to respect user's refresh interval setting instead of always assuming 60 seconds.
+
+### Added
+- Added status notifications for server monitoring in Preferences → Notifications:
+  - "Status Notifications" toggle: alerts when servers go offline/online or services change status.
+  - "Alert Notifications" toggle: (placeholder for future alert threshold configuration).
+- Ping status changes now trigger notifications (Server Online/Offline).
+- Service status monitoring tracks individual services (DNS, FTP, SSH, HTTP, HTTPS, etc.) and alerts when they go offline or come back online.
+- Notification permissions are requested automatically when the app launches.
+
+### Previous Changes
 - Flattened the project structure so sources live at the repository root instead of the nested `iKeyMon/` folder and updated the Xcode project accordingly.
 - Fixed build settings (entitlements, preview assets) and placeholder previews to work with the new layout.
 - Migrated the updated API layer and unified `ServerInfo` model from the previous branch.
 - Added verbose logging in `MainView` to trace server loading, selection, and fetch/ping activity when the list appears empty.
 - Switched `MainView` and `ServerFormView` to the version-aware API client (`APIFactory`/`APIv2_12`) for server summaries and introduced a shared `PingService`.
 - Detection now probes `meta.api_version` so future API versions are selected automatically, and the ping loop logs only failures to keep output quiet.
+- Introduced repository-wide version management via `version.json` + `scripts/sync_version.sh`, ensuring Xcode targets and release artifacts stay aligned.
+- Enhanced `scripts/build_release.sh` to timestamp/harden signatures, notarize DMGs, and optionally publish tagged releases (pre-release by default) with ZIP/DMG assets directly to Gitea when credentials are configured.
+- Integrated Sparkle (via Swift Package Manager) to handle automatic update checks, downloads, signature verification, and relaunches, replacing the previous custom updater UI. Preferences now simply surface Sparkle's check/download toggles.
+- `scripts/build_release.sh` can optionally run Sparkle's `generate_appcast` (when signing key and download prefix env vars are set), producing a ready-to-host `appcast.xml` alongside the ZIP/DMG artifacts.
 - Further reduced MainView console noise by removing redundant refresh/onAppear logs.

NOTES.md

@@ -3,6 +3,5 @@
     dynamic Data
     static Data
 
-add a merker for "reboot required"
-Add dmg download option for macOS
-Add versioning
+add a marker for "reboot required"
+

README.md

@@ -8,9 +8,12 @@ iKeyMon is a native macOS app written in SwiftUI that provides live monitoring f
 - Shows CPU load, memory usage, swap usage, and disk usage
 - Periodic ping via `/api/ping` endpoint to check if a server is reachable
 - Colored status indicator for each server in the list
-- Automatic updates:
+- Automatic refreshes:
   - Ping every 10 seconds
   - Server info every 60 seconds
+- Preferences dialog
+- Built-in Sparkle updater (automatic checks, downloads, and relaunch once a signed release is available)
+- macOS notifications if servers or services become unavailable
 - Organized layout using tabs: General / Resources / Services
 - Stores API keys securely in the macOS Keychain
 - Native macOS look & feel using SwiftUI
@@ -23,11 +26,30 @@ iKeyMon is a native macOS app written in SwiftUI that provides live monitoring f
 
 ## 🛠️ Planned Features
 
-- Preferences dialog
-- macOS notifications if servers or services become unavailable
-- Optional iOS support if there is demand
+- iOS support is a possibility, but it is unclear if or when that will happen
 
-## 🚀 How to Run
+## 📦 Install
+
+### Option 1: Download the app
+
+Download the latest release from:
+
+https://git.24unix.net/tracer/iKeyMon/releases
+
+Then open the DMG and move `iKeyMon.app` to your `Applications` folder.
+
+### Option 2: Install with Homebrew
+
+```bash
+brew tap tracer/tap https://git.24unix.net/tracer/homebrew-tap.git
+brew install --cask ikeymon
+```
+
+### Option 3: Build it yourself
+
+Clone the repository, open it in Xcode, and run the app locally on macOS 14+.
+
+## 🚀 How to Build
 
 Clone the repo and open it in [Xcode](https://developer.apple.com/xcode/). You can build and run the app on macOS 14+.
                                      
@@ -37,15 +59,6 @@ cd iKeyMon
 open iKeyMon.xcodeproj
 ```
 
-### Local release build
-
-Use the helper script to produce distributables in `dist/`:
-
-```bash
-./scripts/build_release.sh
-```
-
-It cleans previous artifacts, builds the `Release` configuration, and drops both `iKeyMon-<version>.zip` and `iKeyMon-<version>.dmg` into the `dist` folder (ignored by git). To enable codesigning + notarization, copy `signing.env.example` to `.signing.env`, fill in your Developer ID identity, Apple ID, team ID, and app-specific password. The script sources that file locally (it remains gitignored) and performs signing/notarization when the values are present.
 ## 📦 License
 
 MIT — see [LICENSE](LICENSE) for details.

Sources/Extensions/View+Shimmer.swift

@@ -15,11 +15,10 @@ struct ShimmerModifier: ViewModifier {
                 guard active else { return }
                 animate()
             }
-            .onChange(of: active) { isActive in
-                if isActive {
-                    phase = -1
-                    animate()
-                }
+            .onChange(of: active) {
+                guard active else { return }
+                phase = -1
+                animate()
             }
     }
 

Sources/Model/API/ApiFactory.swift

@@ -10,6 +10,7 @@ import Foundation
 enum APIVersion: String, CaseIterable {
     case v2_12 = "2.12"
     case v2_13 = "2.13"
+    case v2_14 = "2.14"
     
     static func from(versionString: String) -> APIVersion? {
         if let version = APIVersion(rawValue: versionString) {
@@ -24,7 +25,8 @@ enum APIVersion: String, CaseIterable {
         
         switch (major, minor) {
         case (2, 12): return .v2_12
-        case (2, 13...): return .v2_13
+        case (2, 13): return .v2_13
+        case (2, 14...): return .v2_14
         default: return nil
         }
     }
@@ -36,6 +38,7 @@ protocol AnyServerAPI {
     func fetchMemoryData() async throws -> Any
     func fetchUtilizationData() async throws -> Any
     func fetchServerSummary(apiKey: String) async throws -> ServerInfo
+    func restartServer(apiKey: String) async throws
 }
 
 private struct AnyServerAPIWrapper<T: ServerAPIProtocol>: AnyServerAPI {
@@ -64,6 +67,10 @@ private struct AnyServerAPIWrapper<T: ServerAPIProtocol>: AnyServerAPI {
     func fetchServerSummary(apiKey: String) async throws -> ServerInfo {
         return try await wrapped.fetchServerSummary(apiKey: apiKey)
     }
+
+    func restartServer(apiKey: String) async throws {
+        try await wrapped.restartServer(apiKey: apiKey)
+    }
 }
 
 class APIFactory {
@@ -73,6 +80,8 @@ class APIFactory {
             return AnyServerAPIWrapper(APIv2_12(baseURL: baseURL))
         case .v2_13:
             return AnyServerAPIWrapper(APIv2_13(baseURL: baseURL))
+        case .v2_14:
+            return AnyServerAPIWrapper(APIv2_14(baseURL: baseURL))
         }
     }
     
@@ -104,7 +113,7 @@ class APIFactory {
             }
         }
 
-        return AnyServerAPIWrapper(APIv2_13(baseURL: baseURL))
+        return AnyServerAPIWrapper(APIv2_14(baseURL: baseURL))
     }
 }
 

Sources/Model/API/BaseAPI.swift

@@ -18,6 +18,7 @@ protocol ServerAPIProtocol {
     func fetchMemory() async throws -> MemoryType
     func fetchUtilization() async throws -> UtilizationType
     func fetchServerSummary(apiKey: String) async throws -> ServerInfo
+    func restartServer(apiKey: String) async throws
 }
 
 struct SystemInfo: Codable {
@@ -36,6 +37,15 @@ class BaseAPIClient {
     }
     
     func performRequest<T: Codable>(_ request: URLRequest, responseType: T.Type) async throws -> T {
+        let (data, _) = try await performDataRequest(request)
+        return try JSONDecoder().decode(T.self, from: data)
+    }
+
+    func performRequestWithoutBody(_ request: URLRequest) async throws {
+        _ = try await performDataRequest(request)
+    }
+
+    private func performDataRequest(_ request: URLRequest) async throws -> (Data, HTTPURLResponse) {
         let (data, response) = try await session.data(for: request)
         
         guard let httpResponse = response as? HTTPURLResponse else {
@@ -43,25 +53,61 @@ class BaseAPIClient {
         }
         
         guard 200...299 ~= httpResponse.statusCode else {
-            throw APIError.httpError(httpResponse.statusCode)
+            throw APIError.httpError(
+                httpResponse.statusCode,
+                BaseAPIClient.extractErrorMessage(from: data)
+            )
         }
         
-        return try JSONDecoder().decode(T.self, from: data)
+        return (data, httpResponse)
+    }
+
+    private static func extractErrorMessage(from data: Data) -> String? {
+        guard !data.isEmpty else { return nil }
+
+        if let envelope = try? JSONDecoder().decode(APIErrorEnvelope.self, from: data) {
+            let parts = [envelope.code, envelope.message]
+                .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
+                .filter { !$0.isEmpty }
+
+            if !parts.isEmpty {
+                return parts.joined(separator: " ")
+            }
+        }
+
+        if let text = String(data: data, encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+           !text.isEmpty {
+            return text
+        }
+
+        return nil
     }
 }
 
 enum APIError: Error, LocalizedError {
     case invalidURL
     case invalidResponse
-    case httpError(Int)
+    case httpError(Int, String?)
     case decodingError(Error)
+    case unsupportedFeature(String)
     
     var errorDescription: String? {
         switch self {
         case .invalidURL: return "Invalid URL"
         case .invalidResponse: return "Invalid response"
-        case .httpError(let code): return "HTTP Error: \(code)"
+        case .httpError(let code, let message):
+            if let message, !message.isEmpty {
+                return "HTTP Error: \(code)\n\(message)"
+            }
+            return "HTTP Error: \(code)"
         case .decodingError(let error): return "Decoding error: \(error.localizedDescription)"
+        case .unsupportedFeature(let feature): return "\(feature) is not supported by this host"
         }
     }
 }
+
+private struct APIErrorEnvelope: Decodable {
+    let code: String?
+    let message: String?
+}

Sources/Model/API/PingService.swift

@@ -1,7 +1,21 @@
 import Foundation
+import UserNotifications
 
 enum PingService {
-    static func ping(hostname: String, apiKey: String) async -> Bool {
+    private static var previousPingStates: [String: Bool] = [:]
+    private static var suppressedUntil: [String: Date] = [:]
+
+    static func suppressChecks(for hostname: String, duration: TimeInterval) {
+        suppressedUntil[hostname] = Date().addingTimeInterval(duration)
+    }
+
+    static func ping(hostname: String, apiKey: String, notificationsEnabled: Bool = true) async -> Bool {
+        if let suppressedUntil = suppressedUntil[hostname], suppressedUntil > Date() {
+            return false
+        } else {
+            suppressedUntil.removeValue(forKey: hostname)
+        }
+
         guard let url = URL(string: "https://\(hostname)/api/v2/ping") else {
             print("❌ [PingService] Invalid URL for \(hostname)")
             return false
@@ -15,20 +29,48 @@ enum PingService {
         do {
             let (data, response) = try await URLSession.shared.data(for: request)
             if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode != 200 {
-                if let responseString = String(data: data, encoding: .utf8) {
-                    print("❌ [PingService] HTTP \(httpResponse.statusCode): \(responseString)")
-                }
+                handlePingFailure(for: hostname, notificationsEnabled: notificationsEnabled)
                 return false
             }
 
             if let result = try? JSONDecoder().decode([String: String].self, from: data), result["response"] == "pong" {
+                handlePingSuccess(for: hostname, notificationsEnabled: notificationsEnabled)
                 return true
             } else {
+                handlePingFailure(for: hostname, notificationsEnabled: notificationsEnabled)
                 return false
             }
         } catch {
-            print("❌ [PingService] Error pinging \(hostname): \(error)")
+            handlePingFailure(for: hostname, notificationsEnabled: notificationsEnabled)
             return false
         }
     }
+
+    private static func handlePingSuccess(for hostname: String, notificationsEnabled: Bool) {
+        let wasPreviouslyDown = previousPingStates[hostname] == false
+        previousPingStates[hostname] = true
+
+        if wasPreviouslyDown && notificationsEnabled {
+            sendNotification(title: "Server Online", body: "\(hostname) is now online")
+        }
+    }
+
+    private static func handlePingFailure(for hostname: String, notificationsEnabled: Bool) {
+        let wasPreviouslyUp = previousPingStates[hostname] != false
+        previousPingStates[hostname] = false
+
+        if wasPreviouslyUp && notificationsEnabled {
+            sendNotification(title: "Server Offline", body: "\(hostname) is offline")
+        }
+    }
+
+    private static func sendNotification(title: String, body: String) {
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.sound = .default
+
+        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
+        UNUserNotificationCenter.current().add(request)
+    }
 }

Sources/Model/API/ServerInfo.swift

@@ -65,8 +65,9 @@ struct ServerInfo: Codable, Hashable, Equatable {
     }
 
     struct PHPInterpreter: Codable, Hashable, Identifiable, Equatable {
-        var id: String { versionFull }
+        var id: String { [fullVersion, path ?? ""].joined(separator: "|") }
         let version: String
+        let fullVersion: String
         let path: String?
         let configFile: String?
         let extensions: [String]
@@ -75,6 +76,7 @@ struct ServerInfo: Codable, Hashable, Equatable {
 
         init(
             version: String,
+            fullVersion: String? = nil,
             path: String? = nil,
             configFile: String? = nil,
             extensions: [String] = [],
@@ -82,6 +84,7 @@ struct ServerInfo: Codable, Hashable, Equatable {
             maxExecutionTime: String? = nil
         ) {
             self.version = version
+            self.fullVersion = fullVersion ?? version
             self.path = path
             self.configFile = configFile
             self.extensions = extensions
@@ -89,8 +92,8 @@ struct ServerInfo: Codable, Hashable, Equatable {
             self.maxExecutionTime = maxExecutionTime
         }
 
-        var versionFull: String {
-            var components = [version]
+        var versionWithPath: String {
+            var components = [fullVersion]
             if let path, !path.isEmpty {
                 components.append(path)
             }
@@ -162,10 +165,16 @@ struct ServerInfo: Codable, Hashable, Equatable {
     }
 
     var formattedServerTime: String {
-        guard let date = ServerInfo.isoFormatter.date(from: serverTime) else {
-            return serverTime
+        let normalizedServerTime = ServerInfo.normalizedServerTime(serverTime)
+
+        if let date = ServerInfo.serverTimeParsers
+            .lazy
+            .compactMap({ $0.date(from: normalizedServerTime) })
+            .first {
+            return ServerInfo.displayFormatter.string(from: date)
         }
-        return ServerInfo.displayFormatter.string(from: date)
+
+        return serverTime
     }
 
     var operatingSystemSummary: String? {
@@ -176,24 +185,72 @@ struct ServerInfo: Codable, Hashable, Equatable {
         ].filter { !$0.isEmpty }
         return components.isEmpty ? nil : components.joined(separator: " • ")
     }
+
+    var supportsRestartCommand: Bool {
+        ServerInfo.version(apiVersion, isAtLeast: "2.14")
+    }
 }
 
 // MARK: - Helpers & Sample Data
 
 extension ServerInfo {
-    private static let isoFormatter: ISO8601DateFormatter = {
-        let formatter = ISO8601DateFormatter()
-        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds, .withColonSeparatorInTimeZone]
-        return formatter
+    private static let serverTimeParsers: [ISO8601DateFormatter] = {
+        let withFractional = ISO8601DateFormatter()
+        withFractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+        let withoutFractional = ISO8601DateFormatter()
+        withoutFractional.formatOptions = [.withInternetDateTime]
+
+        let noColonTimeZone = ISO8601DateFormatter()
+        noColonTimeZone.formatOptions = [.withFullDate, .withTime, .withDashSeparatorInDate, .withColonSeparatorInTime, .withTimeZone]
+
+        return [withFractional, withoutFractional, noColonTimeZone]
     }()
 
     private static let displayFormatter: DateFormatter = {
         let formatter = DateFormatter()
+        formatter.locale = .autoupdatingCurrent
         formatter.dateStyle = .medium
         formatter.timeStyle = .medium
         return formatter
     }()
 
+    private static func normalizedServerTime(_ value: String) -> String {
+        if value.range(of: #"[+-]\d{2}:\d{2}$"#, options: .regularExpression) != nil {
+            return value
+        }
+
+        guard value.range(of: #"[+-]\d{4}$"#, options: .regularExpression) != nil else {
+            return value
+        }
+
+        var normalized = value
+        let insertionIndex = normalized.index(normalized.endIndex, offsetBy: -2)
+        normalized.insert(":", at: insertionIndex)
+        return normalized
+    }
+
+    private static func version(_ value: String, isAtLeast minimum: String) -> Bool {
+        let lhs = value
+            .split(separator: ".")
+            .compactMap { Int($0) }
+        let rhs = minimum
+            .split(separator: ".")
+            .compactMap { Int($0) }
+
+        let count = max(lhs.count, rhs.count)
+        for index in 0..<count {
+            let left = index < lhs.count ? lhs[index] : 0
+            let right = index < rhs.count ? rhs[index] : 0
+
+            if left != right {
+                return left > right
+            }
+        }
+
+        return true
+    }
+
     static let placeholder = ServerInfo(
         hostname: "preview.example.com",
         ipAddresses: ["192.168.1.1", "fe80::1"],

Sources/Model/API/Versions/APIv2_12.swift

@@ -181,7 +181,7 @@ class APIv2_12: BaseAPIClient, ServerAPIProtocol {
         }
 
         guard httpResponse.statusCode == 200 else {
-            throw APIError.httpError(httpResponse.statusCode)
+            throw APIError.httpError(httpResponse.statusCode, nil)
         }
 
         let decoder = JSONDecoder()
@@ -189,6 +189,10 @@ class APIv2_12: BaseAPIClient, ServerAPIProtocol {
         let envelope = try decoder.decode(ServerSummaryEnvelope.self, from: data)
         return envelope.toDomain()
     }
+
+    func restartServer(apiKey: String) async throws {
+        throw APIError.unsupportedFeature("Server reboot")
+    }
 }
 
 // MARK: - Server Summary Mapping
@@ -278,6 +282,7 @@ private extension APIv2_12 {
 
         struct AdditionalInterpreter: Decodable {
             let version: String
+            let versionFull: String?
             let path: String?
             let configFile: String?
         }
@@ -398,6 +403,7 @@ private extension APIv2_12 {
                 additionalPHPInterpreters: additionalPhpInterpreters?.map {
                     ServerInfo.PHPInterpreter(
                         version: $0.version,
+                        fullVersion: $0.versionFull,
                         path: $0.path,
                         configFile: $0.configFile,
                         extensions: [],

Sources/Model/API/Versions/APIv2_13.swift

@@ -181,7 +181,7 @@ class APIv2_13: BaseAPIClient, ServerAPIProtocol {
         }
 
         guard httpResponse.statusCode == 200 else {
-            throw APIError.httpError(httpResponse.statusCode)
+            throw APIError.httpError(httpResponse.statusCode, nil)
         }
 
         let decoder = JSONDecoder()
@@ -189,6 +189,10 @@ class APIv2_13: BaseAPIClient, ServerAPIProtocol {
         let envelope = try decoder.decode(ServerSummaryEnvelope.self, from: data)
         return envelope.toDomain()
     }
+
+    func restartServer(apiKey: String) async throws {
+        throw APIError.unsupportedFeature("Server reboot")
+    }
 }
 
 // MARK: - Server Summary Mapping
@@ -278,6 +282,7 @@ private extension APIv2_13 {
 
         struct AdditionalInterpreter: Decodable {
             let version: String
+            let versionFull: String?
             let path: String?
             let configFile: String?
         }
@@ -398,6 +403,7 @@ private extension APIv2_13 {
                 additionalPHPInterpreters: additionalPhpInterpreters?.map {
                     ServerInfo.PHPInterpreter(
                         version: $0.version,
+                        fullVersion: $0.versionFull,
                         path: $0.path,
                         configFile: $0.configFile,
                         extensions: [],

Sources/Model/API/Versions/APIv2_14.swift

@@ -0,0 +1,30 @@
+//
+//  APIv2_14.swift
+//  iKeyMon
+//
+//  Created by tracer on 19.04.26.
+//
+
+import Foundation
+
+class APIv2_14: APIv2_13 {
+    private enum Endpoint: String {
+        case serverReboot = "/api/v2/server/reboot"
+
+        func url(baseURL: URL) -> URL {
+            baseURL.appendingPathComponent(rawValue)
+        }
+    }
+
+    override func restartServer(apiKey: String) async throws {
+        var request = URLRequest(url: Endpoint.serverReboot.url(baseURL: baseURL))
+        request.httpMethod = "POST"
+        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.timeoutInterval = 30
+        request.httpBody = #"{"confirm":true}"#.data(using: .utf8)
+
+        try await performRequestWithoutBody(request)
+    }
+}

Sources/ViewModels/SparkleUpdater.swift

@@ -0,0 +1,127 @@
+import Sparkle
+import Foundation
+import OSLog
+
+@MainActor
+final class SparkleUpdater: NSObject, ObservableObject {
+    private lazy var controller: SPUStandardUpdaterController = {
+        SPUStandardUpdaterController(startingUpdater: true, updaterDelegate: self, userDriverDelegate: nil)
+    }()
+    private let logger = Logger(subsystem: "net.24unix.iKeyMon", category: "Sparkle")
+    private let verboseLogging: Bool
+    @Published var logMessages: [String] = []
+
+    override init() {
+        self.verboseLogging = ProcessInfo.processInfo.environment["SPARKLE_VERBOSE_LOGGING"] == "1"
+        super.init()
+        _ = controller
+        log("Sparkle updater initialized (verbose=\(verboseLogging)).")
+    }
+
+    var automaticallyChecksForUpdates: Bool {
+        get { controller.updater.automaticallyChecksForUpdates }
+        set { controller.updater.automaticallyChecksForUpdates = newValue }
+    }
+
+    var automaticallyDownloadsUpdates: Bool {
+        get { controller.updater.automaticallyDownloadsUpdates }
+        set { controller.updater.automaticallyDownloadsUpdates = newValue }
+    }
+
+    func checkForUpdates() {
+        log("Manual check for updates triggered.")
+        controller.checkForUpdates(nil)
+    }
+
+    private func log(_ message: String) {
+        logger.log("\(message, privacy: .public)")
+        addLogMessage("[INFO] \(message)")
+        if verboseLogging {
+            print("[Sparkle] \(message)")
+        }
+    }
+
+    private func logError(_ message: String) {
+        logger.error("\(message, privacy: .public)")
+        addLogMessage("[ERROR] \(message)")
+        if verboseLogging {
+            fputs("[Sparkle][error] \(message)\n", stderr)
+        }
+    }
+
+    private func addLogMessage(_ message: String) {
+        let timestamp = DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium)
+        let timestampedMessage = "[\(timestamp)] \(message)"
+        logMessages.append(timestampedMessage)
+        if logMessages.count > 100 {
+            logMessages.removeFirst()
+        }
+    }
+
+    private func describe(update item: SUAppcastItem) -> String {
+        let short = item.displayVersionString
+        let build = item.versionString
+        return "\(short) (build \(build))"
+    }
+}
+
+extension SparkleUpdater: SPUUpdaterDelegate {
+    nonisolated func updater(_ updater: SPUUpdater, didFinishLoading appcast: SUAppcast) {
+        Task { @MainActor in
+            log("Loaded Sparkle appcast containing \(appcast.items.count) item(s).")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, didFindValidUpdate item: SUAppcastItem) {
+        Task { @MainActor in
+            log("Found valid update \(describe(update: item))")
+        }
+    }
+
+    nonisolated func updaterDidNotFindUpdate(_ updater: SPUUpdater) {
+        Task { @MainActor in
+            log("No updates available.")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, willDownloadUpdate item: SUAppcastItem, with request: NSMutableURLRequest) {
+        Task { @MainActor in
+            log("Downloading \(describe(update: item)) from \(request.url?.absoluteString ?? "unknown URL")")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem) {
+        Task { @MainActor in
+            log("Finished downloading \(describe(update: item))")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, failedToDownloadUpdate item: SUAppcastItem, error: Error) {
+        Task { @MainActor in
+            logError("Failed to download \(describe(update: item)): \(error.localizedDescription)")
+        }
+    }
+
+    nonisolated func userDidCancelDownload(_ updater: SPUUpdater) {
+        Task { @MainActor in
+            log("User cancelled Sparkle download.")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, willInstallUpdate item: SUAppcastItem) {
+        Task { @MainActor in
+            log("Will install update \(describe(update: item))")
+        }
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, didAbortWithError error: Error) {
+        Task { @MainActor in
+            let errorDescription = error as NSError
+            let details = "Domain: \(errorDescription.domain), Code: \(errorDescription.code), Description: \(error.localizedDescription)"
+            logError("Sparkle aborted: \(details)")
+            if let underlying = errorDescription.userInfo[NSUnderlyingErrorKey] as? NSError {
+                logError("Underlying error: Domain: \(underlying.domain), Code: \(underlying.code), Description: \(underlying.localizedDescription)")
+            }
+        }
+    }
+}

Sources/Views/Cells/InfoCell.swift

@@ -5,12 +5,6 @@
 //  Created by tracer on 03.04.25.
 //
 
-//
-//  ResourcesBarRow.swift
-//  iKeyMon
-//
-//  Created by tracer on 31.03.25.
-//
 
 import SwiftUI
 
@@ -32,6 +26,8 @@ struct InfoCell: View {
                         .font(monospaced ? .system(.body, design: .monospaced) : .body)
                 }
             }
+            
+            
 //            if let subtext {
 //                Text(subtext)
 //                    .font(.caption)

Sources/Views/MainView.swift

@@ -6,6 +6,8 @@
 //
 
 import SwiftUI
+import Combine
+import UserNotifications
 
 struct MainView: View {
     
@@ -17,10 +19,16 @@ struct MainView: View {
     @State private var serverToDelete: Server?
     @State private var showDeleteConfirmation = false
     @State private var isFetchingInfo: Bool = false
-    @State private var refreshTimer = Timer.publish(every: 60, on: .main, in: .common).autoconnect()
-    @State private var progress: Double = 0
-    @State private var lastRefresh = Date()
+    @AppStorage("pingInterval") private var pingInterval: Int = 10
+    @AppStorage("refreshInterval") private var refreshInterval: Int = 60
+    @AppStorage("enableStatusNotifications") private var enableStatusNotifications: Bool = true
+    @AppStorage("enableAlertNotifications") private var enableAlertNotifications: Bool = true
+    @State private var refreshTimer: Timer.TimerPublisher?
+    @State private var refreshSubscription: AnyCancellable?
     @State private var pingTimer: Timer?
+    @State private var restartingServerID: UUID?
+    @State private var lastRefreshInterval: Int?
+    @State private var previousServiceStates: [String: String] = [:]
     private let serverOrderKey = MainView.serverOrderKeyStatic
     private let storedServersKey = MainView.storedServersKeyStatic
 
@@ -30,9 +38,9 @@ struct MainView: View {
     @State private var selectedServerID: UUID?
 
     var body: some View {
-            
-        NavigationSplitView {
-            List(selection: $selectedServerID) {
+        var mainContent: some View {
+            NavigationSplitView {
+                List(selection: $selectedServerID) {
                 ForEach(servers) { server in
                     HStack {
                         Image(systemName: "dot.circle.fill")
@@ -72,11 +80,21 @@ struct MainView: View {
         } detail: {
             if let selectedServerID,
                let index = servers.firstIndex(where: { selectedServerID == $0.id }) {
-                ServerDetailView(server: $servers[index], isFetching: isFetchingInfo)
+                let serverID = servers[index].id
+                ServerDetailView(
+                    server: $servers[index],
+                    isFetching: isFetchingInfo,
+                    canRestart: servers[index].info?.supportsRestartCommand == true,
+                    isRestarting: restartingServerID == serverID
+                ) {
+                    await restartServer(for: serverID)
+                }
             } else {
                 ContentUnavailableView("No Server Selected", systemImage: "server.rack")
             }
+            }
         }
+        return mainContent
         .sheet(isPresented: $showAddServerSheet) {
             ServerFormView(
                 mode: .add,
@@ -97,12 +115,9 @@ struct MainView: View {
             }
             Button("Cancel", role: .cancel) {}
         }
-        .onReceive(refreshTimer) { _ in
-            for server in servers {
-                fetchServerInfo(for: server.id)
-            }
-        }
         .onAppear {
+            requestNotificationPermissions()
+
             let initialID: UUID?
             if let storedID = UserDefaults.standard.string(forKey: "selectedServerID"),
                let uuid = UUID(uuidString: storedID),
@@ -124,13 +139,17 @@ struct MainView: View {
                     await prefetchOtherServers(activeID: initialID)
                 }
             }
-            pingAllServers()
-            pingTimer = Timer.scheduledTimer(withTimeInterval: 10.0, repeats: true) { _ in
-                pingAllServers()
+            setupTimers()
+        }
+        .onChange(of: pingInterval) { _, _ in
+            setupPingTimer()
+        }
+        .onChange(of: refreshInterval) { oldValue, newValue in
+            if oldValue != newValue {
+                setupRefreshTimer()
             }
         }
         .frame(minWidth: 800, minHeight: 450)
-
     }
     
     private func fetchServerInfo(for id: UUID) {
@@ -160,6 +179,7 @@ struct MainView: View {
                         var updated = servers[index]
                         updated.info = info
                         servers[index] = updated
+                        checkServiceStatusChanges(for: server.hostname, newInfo: info)
                     }
                 }
             } catch {
@@ -220,13 +240,34 @@ struct MainView: View {
         for (index, server) in servers.enumerated() {
             Task {
                 let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-                let pingable = await PingService.ping(hostname: server.hostname, apiKey: apiKey)
+                let pingable = await PingService.ping(hostname: server.hostname, apiKey: apiKey, notificationsEnabled: enableStatusNotifications)
                 await MainActor.run {
                     servers[index].pingable = pingable
                 }
-                if !pingable {
-                    print("📶 [MainView] Ping \(server.hostname): offline")
-                }
+            }
+        }
+    }
+
+    private func setupTimers() {
+        setupPingTimer()
+        setupRefreshTimer()
+    }
+
+    private func setupPingTimer() {
+        pingTimer?.invalidate()
+        pingAllServers()
+        pingTimer = Timer.scheduledTimer(withTimeInterval: Double(pingInterval), repeats: true) { _ in
+            pingAllServers()
+        }
+    }
+
+    private func setupRefreshTimer() {
+        refreshSubscription?.cancel()
+        refreshSubscription = nil
+        refreshTimer = Timer.publish(every: Double(refreshInterval), on: .main, in: .common)
+        refreshSubscription = refreshTimer?.autoconnect().sink { _ in
+            for server in servers {
+                fetchServerInfo(for: server.id)
             }
         }
     }
@@ -257,8 +298,130 @@ struct MainView: View {
             return []
         }
     }
+
+    private func requestNotificationPermissions() {
+        Task {
+            do {
+                try await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound])
+            } catch {
+                print("❌ [MainView] Failed to request notification permissions: \(error)")
+            }
+        }
+    }
+
+    private func checkServiceStatusChanges(for hostname: String, newInfo: ServerInfo) {
+        guard let ports = newInfo.ports else { return }
+
+        for port in ports {
+            let key = "\(hostname)-\(port.id)"
+            let previousStatus = previousServiceStates[key]
+            let currentStatus = port.status
+
+            previousServiceStates[key] = currentStatus
+
+            if let previousStatus, previousStatus != currentStatus {
+                if currentStatus == "offline" && enableStatusNotifications {
+                    sendServiceNotification(service: port.service, hostname: hostname, status: "offline")
+                } else if currentStatus == "online" && previousStatus == "offline" && enableStatusNotifications {
+                    sendServiceNotification(service: port.service, hostname: hostname, status: "online")
+                }
+            }
+        }
+    }
+
+    private func sendServiceNotification(service: String, hostname: String, status: String) {
+        let content = UNMutableNotificationContent()
+        content.title = "\(service) \(status.uppercased())"
+        content.body = "\(service) on \(hostname) is \(status)"
+        content.sound = .default
+
+        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
+        UNUserNotificationCenter.current().add(request)
+    }
+
+    private func restartServer(for id: UUID) async -> ServerActionFeedback {
+        guard let server = servers.first(where: { $0.id == id }) else {
+            return ServerActionFeedback(
+                title: "Reboot Failed",
+                message: "The selected server could not be found."
+            )
+        }
+
+        guard server.info?.supportsRestartCommand == true else {
+            return ServerActionFeedback(
+                title: "Reboot Unavailable",
+                message: "\(server.hostname) does not support remote reboot via the API."
+            )
+        }
+
+        guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !apiKey.isEmpty else {
+            return ServerActionFeedback(
+                title: "Reboot Failed",
+                message: "No API key is configured for \(server.hostname)."
+            )
+        }
+
+        guard let baseURL = URL(string: "https://\(server.hostname)") else {
+            return ServerActionFeedback(
+                title: "Reboot Failed",
+                message: "The server URL for \(server.hostname) is invalid."
+            )
+        }
+
+        restartingServerID = id
+        defer { restartingServerID = nil }
+
+        do {
+            let api: AnyServerAPI
+            if let versionString = server.info?.apiVersion,
+               let versionedAPI = APIFactory.createAPI(baseURL: baseURL, versionString: versionString) {
+                api = versionedAPI
+            } else {
+                api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
+            }
+            try await api.restartServer(apiKey: apiKey)
+            PingService.suppressChecks(for: server.hostname, duration: 90)
+
+            return ServerActionFeedback(
+                title: "Reboot Requested",
+                message: "The reboot command was sent to \(server.hostname). The host may become unavailable briefly while it restarts."
+            )
+        } catch let error as URLError where Self.isExpectedRestartDisconnect(error) {
+            PingService.suppressChecks(for: server.hostname, duration: 90)
+            return ServerActionFeedback(
+                title: "Reboot Requested",
+                message: "The reboot command appears to have been accepted by \(server.hostname). The connection dropped while the host was going away, which is expected during a reboot."
+            )
+        } catch APIError.httpError(404, let message) {
+            return ServerActionFeedback(
+                title: "Reboot Unavailable",
+                message: message ?? "\(server.hostname) returned 404 for /api/v2/server/reboot."
+            )
+        } catch {
+            return ServerActionFeedback(
+                title: "Reboot Failed",
+                message: error.localizedDescription
+            )
+        }
+    }
+
+    private static func isExpectedRestartDisconnect(_ error: URLError) -> Bool {
+        switch error.code {
+        case .timedOut,
+             .cannotConnectToHost,
+             .networkConnectionLost,
+             .notConnectedToInternet,
+             .cannotFindHost,
+             .dnsLookupFailed:
+            return true
+        default:
+            return false
+        }
+    }
 }
 
 #Preview {
     MainView()
+        .environmentObject(SparkleUpdater())
 }

Sources/Views/PreferencesView.swift

@@ -2,13 +2,14 @@ import SwiftUI
 
 struct PreferencesView: View {
     private enum Tab: CaseIterable {
-        case monitor, notifications, alerts
+        case monitor, notifications, alerts, updates
 
         var title: String {
             switch self {
             case .monitor: return "Monitor"
             case .notifications: return "Notifications"
             case .alerts: return "Alerts"
+            case .updates: return "Updates"
             }
         }
 
@@ -17,9 +18,12 @@ struct PreferencesView: View {
             case .monitor: return "waveform.path.ecg"
             case .notifications: return "bell.badge"
             case .alerts: return "exclamationmark.triangle"
+            case .updates: return "square.and.arrow.down"
             }
         }
     }
+    @EnvironmentObject private var sparkleUpdater: SparkleUpdater
+    @Environment(\.colorScheme) private var colorScheme
 
     @AppStorage("pingInterval") private var storedPingInterval: Int = 10
     @AppStorage("refreshInterval") private var storedRefreshInterval: Int = 60
@@ -77,14 +81,14 @@ struct PreferencesView: View {
                     .padding(.vertical, 8)
                     .padding(.horizontal, 10)
                     .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(
+                        Capsule(style: .continuous)
+                            .fill(backgroundColor(for: tab))
+                    )
                 }
                 .buttonStyle(.plain)
                 .focusable(false)
                 .contentShape(Capsule())
-                .background(
-                    Capsule(style: .continuous)
-                        .fill(backgroundColor(for: tab))
-                )
                 .foregroundColor(selection == tab ? .white : .primary)
                 .onHover { isHovering in
                     hoveredTab = isHovering ? tab : (hoveredTab == tab ? nil : hoveredTab)
@@ -120,6 +124,9 @@ struct PreferencesView: View {
                 NotificationsPreferencesView()
             case .alerts:
                 AlertsPreferencesView()
+            case .updates:
+                UpdatesPreferencesView()
+                    .environmentObject(sparkleUpdater)
             }
         }
     }
@@ -137,12 +144,39 @@ struct PreferencesView: View {
     }
     private func backgroundColor(for tab: Tab) -> Color {
         if selection == tab {
-            return Color.accentColor
+            return sidebarSelectionColor
         }
         if hoveredTab == tab {
-            return Color.accentColor.opacity(0.2)
+            return sidebarHoverColor
+        }
+        return sidebarBaseColor
+    }
+
+    private var sidebarSelectionColor: Color {
+        switch colorScheme {
+        case .dark:
+            return Color(red: 0.22, green: 0.45, blue: 0.88)
+        default:
+            return Color(red: 0.10, green: 0.39, blue: 0.90)
+        }
+    }
+
+    private var sidebarHoverColor: Color {
+        switch colorScheme {
+        case .dark:
+            return Color(red: 0.20, green: 0.22, blue: 0.27)
+        default:
+            return Color(red: 0.87, green: 0.91, blue: 0.98)
+        }
+    }
+
+    private var sidebarBaseColor: Color {
+        switch colorScheme {
+        case .dark:
+            return Color(red: 0.15, green: 0.16, blue: 0.19)
+        default:
+            return Color(red: 0.96, green: 0.97, blue: 0.99)
         }
-        return Color.accentColor.opacity(0.08)
     }
 }
 
@@ -220,20 +254,52 @@ private struct MonitorPreferencesView: View {
     }
 }
 
-private struct NotificationsPreferencesView: View {
-    var body: some View {
-        VStack(alignment: .leading, spacing: 12) {
-            Text("Notifications")
-                .font(.headline)
-                .padding(.bottom)
+private struct UpdatesPreferencesView: View {
+    @EnvironmentObject var sparkleUpdater: SparkleUpdater
 
-            Text("Configure notification behavior here.")
-                .foregroundColor(.secondary)
+    private var automaticallyChecksBinding: Binding<Bool> {
+        Binding(
+            get: { sparkleUpdater.automaticallyChecksForUpdates },
+            set: { sparkleUpdater.automaticallyChecksForUpdates = $0 }
+        )
+    }
+
+    private var automaticallyDownloadsBinding: Binding<Bool> {
+        Binding(
+            get: { sparkleUpdater.automaticallyDownloadsUpdates },
+            set: { sparkleUpdater.automaticallyDownloadsUpdates = $0 }
+        )
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 18) {
+            Toggle("Automatically check for updates", isOn: automaticallyChecksBinding)
+            Toggle("Automatically download updates", isOn: automaticallyDownloadsBinding)
+
+            Button(action: sparkleUpdater.checkForUpdates) {
+                Label("Check for Updates Now", systemImage: "sparkles")
+            }
 
             Spacer()
         }
+        .toggleStyle(.switch)
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
+
+private struct NotificationsPreferencesView: View {
+    @AppStorage("enableStatusNotifications") private var enableStatusNotifications: Bool = true
+    @AppStorage("enableAlertNotifications") private var enableAlertNotifications: Bool = true
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 18) {
+            Toggle("Status Notifications", isOn: $enableStatusNotifications)
+            Toggle("Alert Notifications", isOn: $enableAlertNotifications)
+
+            Spacer()
+        }
+        .toggleStyle(.switch)
         .frame(maxWidth: .infinity, alignment: .leading)
-        .padding()
     }
 }
 

Sources/Views/ServerDetailView.swift

@@ -7,16 +7,28 @@
 
 import SwiftUI
 
+struct ServerActionFeedback: Identifiable {
+    let id = UUID()
+    let title: String
+    let message: String
+}
+
 struct ServerDetailView: View {
     @Binding var server: Server
     var isFetching: Bool
+    var canRestart: Bool = false
+    var isRestarting: Bool = false
+    var onRestart: (() async -> ServerActionFeedback)? = nil
     @AppStorage("showIntervalIndicator") private var showIntervalIndicator: Bool = true
+    @AppStorage("refreshInterval") private var refreshInterval: Int = 60
 
     private var showPlaceholder: Bool {
         server.info == nil
     }
 
     @State private var progress: Double = 0
+    @State private var showRestartSheet = false
+    @State private var restartFeedback: ServerActionFeedback?
     let timer = Timer.publish(every: 1.0 / 60.0, on: .main, in: .common).autoconnect()
     
     var body: some View {
@@ -32,7 +44,13 @@ struct ServerDetailView: View {
                 VStack(spacing: 0) {
                     Spacer().frame(height: 6)
                     TabView {
-                        GeneralView(server: resolvedBinding)
+                        GeneralView(
+                            server: resolvedBinding,
+                            canRestart: canRestart,
+                            isRestarting: isRestarting
+                        ) {
+                            showRestartSheet = true
+                        }
                             .tabItem {
                                 Text("General").unredacted()
                             }
@@ -56,13 +74,43 @@ struct ServerDetailView: View {
             }
             .padding(0)
         }
+        .overlay(alignment: .bottomTrailing) {
+            if let feedback = restartFeedback {
+                RestartFeedbackBanner(
+                    feedback: feedback,
+                    onDismiss: {
+                        restartFeedback = nil
+                    }
+                )
+                .padding()
+            }
+        }
         .onReceive(timer) { _ in
             guard showIntervalIndicator else { return }
             withAnimation(.linear(duration: 1.0 / 60.0)) {
-                progress += 1.0 / (60.0 * 60.0)
+                progress += 1.0 / (Double(refreshInterval) * 60.0)
                 if progress >= 1 { progress = 0 }
             }
         }
+        .sheet(isPresented: $showRestartSheet) {
+            RestartConfirmationSheet(
+                hostname: server.hostname,
+                isRestarting: isRestarting,
+                onCancel: {
+                    showRestartSheet = false
+                },
+                onConfirm: {
+                    guard let onRestart else { return }
+                    showRestartSheet = false
+                    Task {
+                        let feedback = await onRestart()
+                        await MainActor.run {
+                            restartFeedback = feedback
+                        }
+                    }
+                }
+            )
+        }
     }
     
     private var resolvedBinding: Binding<Server> {
@@ -80,7 +128,8 @@ struct ServerDetailView: View {
 #Preview {
     ServerDetailView(
         server: .constant(Server(id: UUID(), hostname: "preview.example.com", info: ServerInfo.placeholder)),
-        isFetching: false
+        isFetching: false,
+        canRestart: true
     )
 }
 
@@ -96,3 +145,67 @@ private struct LoadingBadge: View {
         .background(.ultraThinMaterial, in: Capsule())
     }
 }
+
+private struct RestartConfirmationSheet: View {
+    let hostname: String
+    let isRestarting: Bool
+    let onCancel: () -> Void
+    let onConfirm: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            Text("Reboot this server?")
+                .font(.title3.weight(.semibold))
+
+            Text("This will send a reboot command to \(hostname).")
+                .foregroundColor(.secondary)
+
+            HStack {
+                Spacer()
+
+                Button("Cancel") {
+                    onCancel()
+                }
+                .keyboardShortcut(.cancelAction)
+                .disabled(isRestarting)
+
+                Button("Reboot", role: .destructive) {
+                    onConfirm()
+                }
+                .keyboardShortcut(.defaultAction)
+                .disabled(isRestarting)
+            }
+        }
+        .padding(24)
+        .frame(width: 420)
+    }
+}
+
+private struct RestartFeedbackBanner: View {
+    let feedback: ServerActionFeedback
+    let onDismiss: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text(feedback.title)
+                .font(.headline)
+
+            Text(feedback.message)
+                .font(.subheadline)
+                .foregroundColor(.secondary)
+
+            HStack {
+                Spacer()
+
+                Button("OK") {
+                    onDismiss()
+                }
+                .keyboardShortcut(.defaultAction)
+            }
+        }
+        .frame(maxWidth: 360, alignment: .leading)
+        .padding(24)
+        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 16, style: .continuous))
+        .shadow(radius: 12)
+    }
+}

Sources/Views/ServerFormView.swift

@@ -20,6 +20,8 @@ struct ServerFormView: View {
     @State private var hostname: String
     @State private var apiKey: String
     @State private var connectionOK: Bool = false
+    @State private var testingConnection: Bool = false
+    @State private var connectionError: String = ""
 
     @Environment(\.dismiss) private var dismiss
     
@@ -55,6 +57,12 @@ struct ServerFormView: View {
             SecureField("API Key", text: $apiKey)
                 .textFieldStyle(RoundedBorderTextFieldStyle())
 
+            if !connectionError.isEmpty {
+                Text(connectionError)
+                    .foregroundColor(.red)
+                    .font(.caption)
+            }
+
             HStack {
                 Button("Cancel") {
                     dismiss()
@@ -65,6 +73,8 @@ struct ServerFormView: View {
                         await testConnection()
                     }
                 }
+                .disabled(hostname.isEmpty || apiKey.isEmpty || testingConnection)
+
                 Button("Save") {
                     saveServer()
                     updateServer()
@@ -102,9 +112,21 @@ struct ServerFormView: View {
         let host = hostname.trimmingCharacters(in: .whitespacesAndNewlines)
         let key = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
 
+        await MainActor.run {
+            testingConnection = true
+            connectionError = ""
+        }
+
         let reachable = await PingService.ping(hostname: host, apiKey: key)
         await MainActor.run {
-            connectionOK = reachable
+            testingConnection = false
+            if reachable {
+                connectionOK = true
+                connectionError = ""
+            } else {
+                connectionOK = false
+                connectionError = "Connection failed. Check hostname and API key."
+            }
         }
 //
 //        guard let url = URL(string: "https://\(host)/api/v2/ping") else {

Sources/Views/Tabs/GeneralView.swift

@@ -9,6 +9,9 @@ import SwiftUI
 
 struct GeneralView: View {
     @Binding var server: Server
+    var canRestart: Bool = false
+    var isRestarting: Bool = false
+    var onRestart: (() -> Void)? = nil
     
     var body: some View {
         GeometryReader { geometry in
@@ -59,10 +62,11 @@ struct GeneralView: View {
                                 var description = os.label.trimmingCharacters(in: .whitespacesAndNewlines)
                                 if description.isEmpty {
                                     description = distro
-                                } else if !distro.isEmpty && distro.caseInsensitiveCompare(description) != .orderedSame {
+                                } else if !distro.isEmpty && description.range(of: distro, options: [.caseInsensitive]) == nil {
                                     description += " • \(distro)"
                                 }
-                                if !os.architecture.isEmpty {
+                                if !os.architecture.isEmpty &&
+                                    description.range(of: os.architecture, options: [.caseInsensitive]) == nil {
                                     description += " (\(os.architecture))"
                                 }
                                 if !description.isEmpty {
@@ -105,11 +109,44 @@ struct GeneralView: View {
                                 if interpreters.isEmpty {
                                     return ["None"]
                                 }
-                                return interpreters.map { $0.versionFull }
+                                let versions = interpreters
+                                    .map { $0.fullVersion }
+                                    .filter { !$0.isEmpty }
+                                if versions.isEmpty {
+                                    return ["None"]
+                                }
+                                return [versions.joined(separator: " • ")]
                             }(),
                             monospaced: true
                         )
                     }
+
+                    if canRestart, let onRestart {
+                        TableRowView(showDivider: false) {
+                            Text("Actions")
+                        } value: {
+                            VStack(alignment: .leading, spacing: 8) {
+                                Button(role: .destructive) {
+                                    onRestart()
+                                } label: {
+                                    if isRestarting {
+                                        HStack(spacing: 8) {
+                                            ProgressView()
+                                                .controlSize(.small)
+                                            Text("Rebooting…")
+                                        }
+                                    } else {
+                                        Label("Reboot Server", systemImage: "arrow.clockwise.circle")
+                                    }
+                                }
+                                .disabled(isRestarting)
+
+                                Text("Sends a reboot command to the selected host.")
+                                    .font(.caption)
+                                    .foregroundColor(.secondary)
+                            }
+                        }
+                    }
                 }
                 .padding()
                 .frame(minHeight: geometry.size.height, alignment: .top)
@@ -125,7 +162,7 @@ struct GeneralView: View {
         @State var previewServer = Server(hostname: "example.com", info: .placeholder)
 
         var body: some View {
-            GeneralView(server: $previewServer)
+            GeneralView(server: $previewServer, canRestart: true)
         }
     }
 

Sources/Views/Tabs/ResourcesView.swift

@@ -17,6 +17,10 @@ import SwiftUI
 struct ResourcesView: View {
     @Binding var server: Server
 
+    private var displayInfo: ServerInfo {
+        server.info ?? .placeholder
+    }
+
     var body: some View {
         GeometryReader { geometry in
             ScrollView {
@@ -25,40 +29,40 @@ struct ResourcesView: View {
                         Text("CPU Load")
                     } value: {
                         LoadBarCell(
-                            percent: (server.info?.load.percent)!,
-                            load1: (server.info?.load.minute1)!,
-                            load5: (server.info?.load.minute5)!,
-                            load15: (server.info?.load.minute15)!
+                            percent: displayInfo.load.percent,
+                            load1: displayInfo.load.minute1,
+                            load5: displayInfo.load.minute5,
+                            load15: displayInfo.load.minute15
                         )
                     }
                     TableRowView {
                         Text("Memory")
                     } value: {
                         UsageBarCell(
-                            free: (server.info?.memory.free)!,
-                            used: (server.info?.memory.used)!,
-                            total: (server.info?.memory.total)!,
-                            percent: (server.info?.memory.percent)!
+                            free: displayInfo.memory.free,
+                            used: displayInfo.memory.used,
+                            total: displayInfo.memory.total,
+                            percent: displayInfo.memory.percent
                         )
                     }
                     TableRowView {
                         Text("Swap")
                     } value: {
                         UsageBarCell(
-                            free: (server.info?.swap.free)!,
-                            used: (server.info?.swap.used)!,
-                            total: (server.info?.swap.total)!,
-                            percent: (server.info?.swap.percent)!
+                            free: displayInfo.swap.free,
+                            used: displayInfo.swap.used,
+                            total: displayInfo.swap.total,
+                            percent: displayInfo.swap.percent
                         )
                     }
                     TableRowView {
                         Text("SSD")
                     } value: {
                         UsageBarCell(
-                            free: (server.info?.diskSpace.free)!,
-                            used: (server.info?.diskSpace.used)!,
-                            total: (server.info?.diskSpace.total)!,
-                            percent: (server.info?.diskSpace.percent)!
+                            free: displayInfo.diskSpace.free,
+                            used: displayInfo.diskSpace.used,
+                            total: displayInfo.diskSpace.total,
+                            percent: displayInfo.diskSpace.percent
                         )
                     }
                 }

Sources/iKeyMonApp.swift

@@ -12,6 +12,8 @@ import AppKit
 
 @main
 struct iKeyMonApp: App {
+    @StateObject private var sparkleUpdater = SparkleUpdater()
+
     init() {
         #if os(macOS)
         if let customIcon = NSImage(named: "AppIcon") {
@@ -23,6 +25,7 @@ struct iKeyMonApp: App {
     var body: some Scene {
         WindowGroup {
             MainView()
+                .environmentObject(sparkleUpdater)
                 .onDisappear {
                     NSApp.terminate(nil)
                 }
@@ -32,6 +35,7 @@ struct iKeyMonApp: App {
         Settings {
             PreferencesView()
                 .padding()
+                .environmentObject(sparkleUpdater)
         }
     }
 }

Sparkle/appcast.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" version="2.0">
+    <channel>
+        <title>iKeyMon</title>
+        <item>
+            <title>26.1.7</title>
+            <pubDate>Sun, 19 Apr 2026 16:54:42 +0200</pubDate>
+            <sparkle:version>177</sparkle:version>
+            <sparkle:shortVersionString>26.1.7</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.1.7/iKeyMon-26.1.7.zip" length="3106520" type="application/octet-stream" sparkle:edSignature="xuNlxCsTtVgroriFU7fphcfHxAEC8cpd6tHnHMXknJ2jvKm27ShQMqjSW2jdqNAz0a0kNtPM8HwTL+e6nvUyCQ=="/>
+        </item>
+        <item>
+            <title>26.1.6</title>
+            <pubDate>Sun, 19 Apr 2026 15:26:19 +0200</pubDate>
+            <sparkle:version>175</sparkle:version>
+            <sparkle:shortVersionString>26.1.6</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.1.6/iKeyMon-26.1.6.zip" length="3063130" type="application/octet-stream" sparkle:edSignature="QPy3zm31ZTXE9grlj7Ul6kEG2t0veODEBjJ/qADM8A88lLJ8V9L4WhNnD8wmM7Urh1O6eZKl1qrCLTk0oo3WBA=="/>
+        </item>
+        <item>
+            <title>26.1.5</title>
+            <pubDate>Sun, 19 Apr 2026 12:09:33 +0200</pubDate>
+            <sparkle:version>173</sparkle:version>
+            <sparkle:shortVersionString>26.1.5</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.1.5/iKeyMon-26.1.5.zip" length="3065231" type="application/octet-stream" sparkle:edSignature="HVV7iZ4eyJC1VMh2q4GUoAESZnk4HoFU00QlA9qM4X4dJAT5oBEVB55m4wuF4u9iVFAeohkB0vleLlV39mxrBA=="/>
+        </item>
+    </channel>
+</rss>

hooks/pre-push

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+REMOTE_NAME="${1:-origin}"
+QUIET_RELEASE="${QUIET_RELEASE:-1}"
+RELEASE_LOG="${RELEASE_LOG:-$ROOT_DIR/.git/release.log}"
+
+if [[ -n "${SKIP_RELEASE:-}" ]]; then
+  echo "release: skipped (SKIP_RELEASE=1)"
+  exit 0
+fi
+
+head_subject="$(git -C "$ROOT_DIR" log -1 --pretty=%s 2>/dev/null || true)"
+if [[ "$head_subject" =~ ^chore:\ release\  ]]; then
+  echo "release: skipped (HEAD is already a release commit)"
+  exit 0
+fi
+
+should_release=false
+release_local_ref=""
+release_remote_ref=""
+while read -r local_ref local_sha remote_ref remote_sha; do
+  [[ -z "${local_ref:-}" ]] && continue
+  if [[ "$local_ref" == "refs/heads/master" || "$remote_ref" == "refs/heads/master" ]]; then
+    should_release=true
+    release_local_ref="$local_ref"
+    release_remote_ref="${remote_ref:-refs/heads/master}"
+  fi
+done
+
+if [[ "$should_release" != true ]]; then
+  current_branch="$(git -C "$ROOT_DIR" symbolic-ref --short -q HEAD || true)"
+  if [[ "$current_branch" == "master" ]]; then
+    should_release=true
+    release_local_ref="refs/heads/master"
+    release_remote_ref="refs/heads/master"
+  fi
+fi
+
+if [[ "$should_release" != true ]]; then
+  exit 0
+fi
+
+if [[ "$QUIET_RELEASE" == "1" ]]; then
+  mkdir -p "$(dirname "$RELEASE_LOG")"
+  : >"$RELEASE_LOG"
+fi
+
+run_logged() {
+  if [[ "$QUIET_RELEASE" == "1" ]]; then
+    "$@" >>"$RELEASE_LOG" 2>&1
+  else
+    "$@"
+  fi
+}
+
+if [[ "$QUIET_RELEASE" == "1" ]]; then
+  NEW_VERSION="$("$ROOT_DIR/scripts/bump_version.sh" 2>>"$RELEASE_LOG" | tee -a "$RELEASE_LOG")"
+else
+  NEW_VERSION="$("$ROOT_DIR/scripts/bump_version.sh")"
+fi
+run_logged "$ROOT_DIR/scripts/sync_version.sh"
+
+git -C "$ROOT_DIR" add "$ROOT_DIR/version.json" "$ROOT_DIR/iKeyMon.xcodeproj/project.pbxproj"
+
+echo "release: building v${NEW_VERSION}..."
+if ! run_logged "$ROOT_DIR/scripts/build_release.sh"; then
+  echo "release: failed (log: $RELEASE_LOG)"
+  exit 1
+fi
+
+git -C "$ROOT_DIR" add "$ROOT_DIR/version.json" "$ROOT_DIR/iKeyMon.xcodeproj/project.pbxproj" "$ROOT_DIR/Sparkle/appcast.xml"
+
+if git -C "$ROOT_DIR" diff --cached --quiet; then
+  echo "release: no changes detected; continuing push"
+  exit 0
+else
+  run_logged git -C "$ROOT_DIR" commit -m "chore: release ${NEW_VERSION}" || {
+    echo "release: commit failed (log: $RELEASE_LOG)"
+    exit 1
+  }
+fi
+
+echo "release: created commit for v${NEW_VERSION}; run 'git push' again to push the new release commit"
+exit 1

iKeyMon-Info.plist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SUFeedURL</key>
+	<string>https://git.24unix.net/tracer/iKeyMon/raw/branch/master/Sparkle/appcast.xml</string>
+	<key>SUPublicEDKey</key>
+	<string>EgJgrOGQ79L5me616jA7kDCEOgx+Rg11uYLYLLIyzTI=</string>
+	<key>SUEnableInstallerLauncherService</key>
+	<false/>
+</dict>
+</plist>

iKeyMon.entitlements

@@ -3,10 +3,12 @@
 <plist version="1.0">
 <dict>
 	<key>com.apple.security.app-sandbox</key>
-	<true/>
-	<key>com.apple.security.files.user-selected.read-only</key>
-	<true/>
+	<false/>
 	<key>com.apple.security.network.client</key>
 	<true/>
+	<key>com.apple.security.files.downloads.read-write</key>
+	<true/>
+	<key>com.apple.security.files.user-selected.read-write</key>
+	<true/>
 </dict>
 </plist>

iKeyMon.xcodeproj/project.pbxproj

@@ -7,18 +7,36 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		5221016D2EE5E82700D04952 /* appcast.xml in Resources */ = {isa = PBXBuildFile; fileRef = 5221016B2EE5E82700D04952 /* appcast.xml */; };
 		52A9B79F2EC8E7EE004DD4A2 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 52A9B7872EC8E7EE004DD4A2 /* Assets.xcassets */; };
 		52A9B8222EC8FA8A004DD4A2 /* CHANGELOG.md in Resources */ = {isa = PBXBuildFile; fileRef = 52A9B8212EC8FA8A004DD4A2 /* CHANGELOG.md */; };
 		52A9B9722ECF751C004DD4A2 /* signing.env.example in Resources */ = {isa = PBXBuildFile; fileRef = 52A9B9712ECF751C004DD4A2 /* signing.env.example */; };
+		52A9BD112ED377F7004DD4A2 /* Sparkle in Frameworks */ = {isa = PBXBuildFile; productRef = 52A9BD102ED377F7004DD4A2 /* Sparkle */; };
+		52A9BECA2ED3874F004DD4A2 /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 52A9BEC92ED3874F004DD4A2 /* README.md */; };
 /* End PBXBuildFile section */
 
+/* Begin PBXCopyFilesBuildPhase section */
+		52A9BD152ED37BD8004DD4A2 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 6;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
 /* Begin PBXFileReference section */
 		5203C24D2D997D2800576D4A /* iKeyMon.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = iKeyMon.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		5221016B2EE5E82700D04952 /* appcast.xml */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = appcast.xml; sourceTree = "<group>"; };
 		52A9B7872EC8E7EE004DD4A2 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
 		52A9B7882EC8E7EE004DD4A2 /* iKeyMon.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = iKeyMon.entitlements; sourceTree = "<group>"; };
 		52A9B8212EC8FA8A004DD4A2 /* CHANGELOG.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = CHANGELOG.md; sourceTree = "<group>"; };
 		52A9B8BA2ECA35FB004DD4A2 /* NOTES.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = NOTES.md; sourceTree = "<group>"; };
 		52A9B9712ECF751C004DD4A2 /* signing.env.example */ = {isa = PBXFileReference; lastKnownFileType = text; path = signing.env.example; sourceTree = "<group>"; };
+		52A9BEC92ED3874F004DD4A2 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
+		52A9C38F2ED4D753004DD4A2 /* iKeyMon-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "iKeyMon-Info.plist"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFileSystemSynchronizedRootGroup section */
@@ -39,6 +57,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				52A9BD112ED377F7004DD4A2 /* Sparkle in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -48,6 +67,7 @@
 		5203C2442D997D2800576D4A = {
 			isa = PBXGroup;
 			children = (
+				52A9C38F2ED4D753004DD4A2 /* iKeyMon-Info.plist */,
 				52A9B8BE2ECB68B5004DD4A2 /* Sources */,
 				52A9B7872EC8E7EE004DD4A2 /* Assets.xcassets */,
 				52A9B7882EC8E7EE004DD4A2 /* iKeyMon.entitlements */,
@@ -56,6 +76,9 @@
 				52A9B8212EC8FA8A004DD4A2 /* CHANGELOG.md */,
 				52A9B8BA2ECA35FB004DD4A2 /* NOTES.md */,
 				52A9B9712ECF751C004DD4A2 /* signing.env.example */,
+				52A9BEC92ED3874F004DD4A2 /* README.md */,
+				52A9BD122ED37E08004DD4A2 /* Frameworks */,
+				5221016C2EE5E82700D04952 /* Sparkle */,
 			);
 			sourceTree = "<group>";
 		};
@@ -67,6 +90,21 @@
 			name = Products;
 			sourceTree = "<group>";
 		};
+		5221016C2EE5E82700D04952 /* Sparkle */ = {
+			isa = PBXGroup;
+			children = (
+				5221016B2EE5E82700D04952 /* appcast.xml */,
+			);
+			path = Sparkle;
+			sourceTree = "<group>";
+		};
+		52A9BD122ED37E08004DD4A2 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
@@ -77,6 +115,7 @@
 				5203C2492D997D2800576D4A /* Sources */,
 				5203C24A2D997D2800576D4A /* Frameworks */,
 				5203C24B2D997D2800576D4A /* Resources */,
+				52A9BD152ED37BD8004DD4A2 /* CopyFiles */,
 			);
 			buildRules = (
 			);
@@ -88,6 +127,7 @@
 			);
 			name = iKeyMon;
 			packageProductDependencies = (
+				52A9BD102ED377F7004DD4A2 /* Sparkle */,
 			);
 			productName = iKeyMon;
 			productReference = 5203C24D2D997D2800576D4A /* iKeyMon.app */;
@@ -117,6 +157,9 @@
 			);
 			mainGroup = 5203C2442D997D2800576D4A;
 			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				52A9BD0F2ED377F7004DD4A2 /* XCRemoteSwiftPackageReference "Sparkle" */,
+			);
 			preferredProjectObjectVersion = 77;
 			productRefGroup = 5203C24E2D997D2800576D4A /* Products */;
 			projectDirPath = "";
@@ -133,6 +176,8 @@
 			buildActionMask = 2147483647;
 			files = (
 				52A9B8222EC8FA8A004DD4A2 /* CHANGELOG.md in Resources */,
+				52A9BECA2ED3874F004DD4A2 /* README.md in Resources */,
+				5221016D2EE5E82700D04952 /* appcast.xml in Resources */,
 				52A9B79F2EC8E7EE004DD4A2 /* Assets.xcassets in Resources */,
 				52A9B9722ECF751C004DD4A2 /* signing.env.example in Resources */,
 			);
@@ -277,19 +322,22 @@
 				CODE_SIGN_ENTITLEMENTS = iKeyMon.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 177;
 				DEVELOPMENT_ASSET_PATHS = "\"Preview Content\"";
 				DEVELOPMENT_TEAM = Q5486ZVAFT;
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = "iKeyMon-Info.plist";
 				INFOPLIST_KEY_CFBundleIconName = AppIcon;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "";
+				INFOPLIST_KEY_SUFeedURL = "https://git.24unix.net/tracer/iKeyMon/releases/appcast.xml";
+				INFOPLIST_KEY_SUPublicEDKey = "EgJgrOGQ79L5me616jA7kDCEOgx+Rg11uYLYLLIyzTI=";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 26.1.7;
 				PRODUCT_BUNDLE_IDENTIFIER = net.24unix.iKeyMon;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -305,19 +353,22 @@
 				CODE_SIGN_ENTITLEMENTS = iKeyMon.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 177;
 				DEVELOPMENT_ASSET_PATHS = "\"Preview Content\"";
 				DEVELOPMENT_TEAM = Q5486ZVAFT;
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = "iKeyMon-Info.plist";
 				INFOPLIST_KEY_CFBundleIconName = AppIcon;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "";
+				INFOPLIST_KEY_SUFeedURL = "https://git.24unix.net/tracer/iKeyMon/releases/appcast.xml";
+				INFOPLIST_KEY_SUPublicEDKey = "EgJgrOGQ79L5me616jA7kDCEOgx+Rg11uYLYLLIyzTI=";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 26.1.7;
 				PRODUCT_BUNDLE_IDENTIFIER = net.24unix.iKeyMon;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -347,6 +398,25 @@
 			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
+
+/* Begin XCRemoteSwiftPackageReference section */
+		52A9BD0F2ED377F7004DD4A2 /* XCRemoteSwiftPackageReference "Sparkle" */ = {
+			isa = XCRemoteSwiftPackageReference;
+			repositoryURL = "https://github.com/sparkle-project/Sparkle";
+			requirement = {
+				kind = upToNextMajorVersion;
+				minimumVersion = 2.8.1;
+			};
+		};
+/* End XCRemoteSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		52A9BD102ED377F7004DD4A2 /* Sparkle */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = 52A9BD0F2ED377F7004DD4A2 /* XCRemoteSwiftPackageReference "Sparkle" */;
+			productName = Sparkle;
+		};
+/* End XCSwiftPackageProductDependency section */
 	};
 	rootObject = 5203C2452D997D2800576D4A /* Project object */;
 }

iKeyMon.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -0,0 +1,15 @@
+{
+  "originHash" : "e721da7f9826abdffcb6185e886155efa2514bd6234475f1afa893e29eb258d6",
+  "pins" : [
+    {
+      "identity" : "sparkle",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/sparkle-project/Sparkle",
+      "state" : {
+        "revision" : "5581748cef2bae787496fe6d61139aebe0a451f6",
+        "version" : "2.8.1"
+      }
+    }
+  ],
+  "version" : 3
+}

scripts/build_release.sh

@@ -3,34 +3,171 @@ set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 BUILD_DIR="$ROOT_DIR/build"
+DERIVED_DATA_DIR="$BUILD_DIR/derived-data"
 ARTIFACTS_DIR="$ROOT_DIR/dist"
 SCHEME="iKeyMon"
 PROJECT="iKeyMon.xcodeproj"
 CREDENTIALS_FILE="$ROOT_DIR/.signing.env"
+VERSION_FILE="$ROOT_DIR/version.json"
+DERIVED_DATA_ROOT="${DERIVED_DATA_ROOT:-$HOME/Library/Developer/Xcode/DerivedData}"
+
+find_generate_appcast() {
+  if [[ -n "${SPARKLE_GENERATE_APPCAST:-}" && -x "${SPARKLE_GENERATE_APPCAST}" ]]; then
+    echo "$SPARKLE_GENERATE_APPCAST"
+    return
+  fi
+
+  if [[ -d "$DERIVED_DATA_ROOT" ]]; then
+    local candidate
+    candidate="$(find "$DERIVED_DATA_ROOT" -path "*/SourcePackages/artifacts/sparkle/Sparkle/bin/generate_appcast" -type f 2>/dev/null | head -n 1 || true)"
+    if [[ -n "$candidate" ]]; then
+      echo "$candidate"
+      return
+    fi
+  fi
+}
+
+generate_appcast() {
+  local generator
+  generator="$(find_generate_appcast)"
+  local download_prefix=""
+  if [[ -n "${SPARKLE_DOWNLOAD_BASE_TEMPLATE:-}" ]]; then
+    download_prefix="${SPARKLE_DOWNLOAD_BASE_TEMPLATE//\{\{VERSION\}\}/$VERSION}"
+  elif [[ -n "${SPARKLE_DOWNLOAD_BASE_URL:-}" ]]; then
+    download_prefix="${SPARKLE_DOWNLOAD_BASE_URL%/}/v${VERSION}"
+  fi
+
+  # Ensure the version segment is present to match Gitea's /download/vX.Y.Z/ layout.
+  if [[ -n "$download_prefix" ]] && [[ "$download_prefix" != *"/$VERSION"* ]]; then
+    download_prefix="${download_prefix%/}/v${VERSION}"
+  fi
+
+  if [[ -z "$generator" || -z "${SPARKLE_EDDSA_KEY_FILE:-}" || -z "$download_prefix" ]]; then
+    echo "ℹ️ Skipping Sparkle appcast generation (generator/key/download prefix not configured)."
+    return
+  fi
+
+  local sparkle_cache="$HOME/Library/Caches/Sparkle_generate_appcast"
+  rm -rf "$sparkle_cache"
+
+  local output="$SPARKLE_APPCAST_OUTPUT"
+  mkdir -p "$(dirname "$output")"
+  local staging_dir
+  staging_dir="$(mktemp -d)"
+  cp "$ARTIFACTS_DIR"/*.zip "$staging_dir"/ 2>/dev/null || true
+
+  if ! ls "$staging_dir"/*.zip >/dev/null 2>&1; then
+    echo "ℹ️ Skipping Sparkle appcast generation (no ZIP archives found)."
+    rm -rf "$staging_dir"
+    return
+  fi
+
+  echo "🧾 Generating Sparkle appcast at $output"
+  if ! "$generator" \
+    --download-url-prefix "$download_prefix" \
+    --ed-key-file "$SPARKLE_EDDSA_KEY_FILE" \
+    -o "$output" \
+    "$staging_dir"; then
+    echo "⚠️ Sparkle appcast generation failed."
+  fi
+  rm -rf "$staging_dir"
+}
+
+sign_update_artifacts() {
+  local signer
+  signer="$(find "$DERIVED_DATA_ROOT" -path "*/SourcePackages/artifacts/sparkle/Sparkle/bin/sign_update" -type f 2>/dev/null | head -n 1 || true)"
+  if [[ -z "$signer" || -z "${SPARKLE_EDDSA_KEY_FILE:-}" ]]; then
+    echo "ℹ️ Skipping Sparkle signing (sign_update or SPARKLE_EDDSA_KEY_FILE missing)."
+    return
+  fi
+  echo "🔑 Signing ${ZIP_NAME} for Sparkle feed"
+  if ! "$signer" "${ARTIFACTS_DIR}/${ZIP_NAME}" --ed-key-file "${SPARKLE_EDDSA_KEY_FILE}"; then
+    echo "⚠️ sign_update failed (continuing without signature)"
+  fi
+}
+
+rewrite_appcast_urls() {
+  : # no-op (old helper removed)
+}
+
+submit_for_notarization() {
+  local target="$1"
+  local label="$2"
+  echo "📝 Submitting ${label} for notarization..."
+  xcrun notarytool submit "$target" \
+    --apple-id "$NOTARY_APPLE_ID" \
+    --team-id "$NOTARY_TEAM_ID" \
+    --password "$NOTARY_PASSWORD" \
+    --wait
+}
+
+notarize_app_bundle() {
+  local bundle="$1"
+  local label="$2"
+  if [[ -z "${NOTARY_APPLE_ID:-}" || -z "${NOTARY_TEAM_ID:-}" || -z "${NOTARY_PASSWORD:-}" ]]; then
+    echo "ℹ️ Skipping notarization for ${label} (NOTARY_* variables not set)."
+    return 1
+  fi
+
+  local tmp_dir
+  tmp_dir="$(mktemp -d)"
+  local archive="$tmp_dir/$(basename "$bundle").zip"
+  ditto -c -k --keepParent "$bundle" "$archive"
+
+  submit_for_notarization "$archive" "$label"
+  xcrun stapler staple "$bundle"
+  rm -rf "$tmp_dir"
+}
+
+notarize_artifact() {
+  local artifact="$1"
+  local label="$2"
+  if [[ -z "${NOTARY_APPLE_ID:-}" || -z "${NOTARY_TEAM_ID:-}" || -z "${NOTARY_PASSWORD:-}" ]]; then
+    echo "ℹ️ Skipping notarization for ${label} (NOTARY_* variables not set)."
+    return 1
+  fi
+  submit_for_notarization "$artifact" "$label"
+  xcrun stapler staple "$artifact"
+}
 
 if [[ -f "$CREDENTIALS_FILE" ]]; then
+  set -a
   # shellcheck disable=SC1090
   source "$CREDENTIALS_FILE"
+  set +a
 fi
 
-rm -rf "$BUILD_DIR" "$ARTIFACTS_DIR"
-mkdir -p "$ARTIFACTS_DIR"
+: "${SPARKLE_APPCAST_OUTPUT:=$ROOT_DIR/Sparkle/appcast.xml}"
+export SPARKLE_APPCAST_OUTPUT
+
+"$ROOT_DIR/scripts/sync_version.sh"
+
+rm -rf "$DERIVED_DATA_DIR" "$ARTIFACTS_DIR"
+mkdir -p "$BUILD_DIR" "$ARTIFACTS_DIR"
 
 xcodebuild \
   -project "$ROOT_DIR/$PROJECT" \
   -scheme "$SCHEME" \
   -configuration Release \
-  -derivedDataPath "$BUILD_DIR" \
+  -derivedDataPath "$DERIVED_DATA_DIR" \
   CODE_SIGNING_ALLOWED=NO \
   clean build
 
-APP_PATH="$BUILD_DIR/Build/Products/Release/iKeyMon.app"
+APP_PATH="$DERIVED_DATA_DIR/Build/Products/Release/iKeyMon.app"
 if [[ ! -d "$APP_PATH" ]]; then
   echo "❌ Failed to find built app at $APP_PATH"
   exit 1
 fi
 
 if [[ -n "${CODESIGN_IDENTITY:-}" ]]; then
+  echo "🔏 Codesigning Sparkle framework..."
+  codesign \
+    --force \
+    --options runtime \
+    --timestamp \
+    --sign "$CODESIGN_IDENTITY" \
+    "$APP_PATH/Contents/Frameworks/Sparkle.framework"
+
   echo "🔏 Codesigning app with identity: $CODESIGN_IDENTITY"
   codesign \
     --deep \
@@ -44,6 +181,8 @@ else
   echo "⚠️ Skipping codesign (CODESIGN_IDENTITY not set)."
 fi
 
+notarize_app_bundle "$APP_PATH" "iKeyMon.app"
+
 STAGING_DIR=$(mktemp -d)
 mkdir -p "$STAGING_DIR"
 cp -R "$APP_PATH" "$STAGING_DIR/"
@@ -51,35 +190,38 @@ ln -s /Applications "$STAGING_DIR/Applications"
 mkdir -p "$STAGING_DIR/.background"
 cp "$ROOT_DIR/Assets/dmg_background.png" "$STAGING_DIR/.background/background.png"
 
-VERSION=$(xcodebuild \
-  -project "$ROOT_DIR/$PROJECT" \
-  -scheme "$SCHEME" \
-  -configuration Release \
-  -showBuildSettings | awk '/MARKETING_VERSION/ {print $3; exit}')
-if [[ -z "$VERSION" ]]; then
-  VERSION="dev"
-fi
+VERSION="$(python3 - <<'PY' "$VERSION_FILE"
+import json, sys
+with open(sys.argv[1], "r", encoding="utf-8") as handle:
+    data = json.load(handle)
+print(data.get("marketing_version", "dev"))
+PY
+)"
 ZIP_NAME="iKeyMon-${VERSION}.zip"
-pushd "$(dirname "$APP_PATH")" >/dev/null
-zip -r "$ARTIFACTS_DIR/$ZIP_NAME" "$(basename "$APP_PATH")"
-popd >/dev/null
+ditto -c -k --keepParent "$APP_PATH" "$ARTIFACTS_DIR/$ZIP_NAME"
 
 DMG_NAME="iKeyMon-${VERSION}.dmg"
 hdiutil create -volname "iKeyMon" -srcfolder "$STAGING_DIR" -ov -format UDZO "$ARTIFACTS_DIR/$DMG_NAME"
 
+sign_update_artifacts
+
 if [[ -n "${NOTARY_APPLE_ID:-}" && -n "${NOTARY_TEAM_ID:-}" && -n "${NOTARY_PASSWORD:-}" ]]; then
-  echo "📝 Submitting DMG for notarization..."
-  xcrun notarytool submit "$ARTIFACTS_DIR/$DMG_NAME" \
-    --apple-id "$NOTARY_APPLE_ID" \
-    --team-id "$NOTARY_TEAM_ID" \
-    --password "$NOTARY_PASSWORD" \
-    --wait
-  xcrun stapler staple "$ARTIFACTS_DIR/$DMG_NAME"
+  notarize_artifact "$ARTIFACTS_DIR/$DMG_NAME" "$DMG_NAME"
 else
-  echo "⚠️ Skipping notarization (NOTARY_* variables not set)."
+  echo "⚠️ Skipping DMG notarization (NOTARY_* variables not set)."
 fi
 rm -rf "$STAGING_DIR"
 
+generate_appcast
+
+if [[ -n "${GITEA_TOKEN:-}" && -n "${GITEA_OWNER:-}" && -n "${GITEA_REPO:-}" ]]; then
+  "$ROOT_DIR/scripts/publish_release.sh" "$VERSION" "$ARTIFACTS_DIR/$ZIP_NAME" "$ARTIFACTS_DIR/$DMG_NAME"
+  "$ROOT_DIR/scripts/update_homebrew_tap.sh" "$VERSION" "$ARTIFACTS_DIR/$DMG_NAME"
+else
+  echo "ℹ️ Skipping Gitea release publishing (GITEA_* variables not fully set)."
+  echo "ℹ️ Skipping Homebrew tap update because release publishing was skipped."
+fi
+
 echo "✅ Build complete. Artifacts:"
 echo "   - $ARTIFACTS_DIR/$ZIP_NAME"
 echo "   - $ARTIFACTS_DIR/$DMG_NAME"

scripts/bump_version.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VERSION_FILE="$ROOT_DIR/version.json"
+
+new_version="$(python3 - "$VERSION_FILE" <<'PY'
+import json, sys, pathlib
+path = pathlib.Path(sys.argv[1])
+data = json.loads(path.read_text())
+current = data.get("marketing_version")
+if not current:
+    raise SystemExit("marketing_version missing in version.json")
+parts = current.split(".")
+if len(parts) != 3 or not all(part.isdigit() for part in parts):
+    raise SystemExit(f"Invalid marketing_version format: {current}")
+parts[-1] = str(int(parts[-1]) + 1)
+data["marketing_version"] = ".".join(parts)
+path.write_text(json.dumps(data, indent=2) + "\n")
+print(data["marketing_version"])
+PY
+)"
+
+echo "$new_version"

scripts/publish_release.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VERSION="$1"
+ZIP_PATH="$2"
+DMG_PATH="$3"
+
+: "${GITEA_TOKEN:?Set GITEA_TOKEN in .signing.env}"
+: "${GITEA_OWNER:?Set GITEA_OWNER in .signing.env}"
+: "${GITEA_REPO:?Set GITEA_REPO in .signing.env}"
+
+TARGET_COMMIT="${GITEA_TARGET_COMMIT:-$(git -C "$ROOT_DIR" rev-parse HEAD)}"
+API_BASE="${GITEA_API_BASE:-https://git.24unix.net/api/v1}"
+API_BASE="${API_BASE%/}"
+RELEASE_TAG="v${VERSION}"
+API_URL="${API_BASE}/repos/${GITEA_OWNER}/${GITEA_REPO}"
+CHANGELOG_FILE="$ROOT_DIR/CHANGELOG.md"
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "❌ jq is required to parse Gitea responses." >&2
+  exit 1
+fi
+
+# Extract changelog for this version
+extract_changelog() {
+  local version="$1"
+  local changelog_file="$2"
+
+  if [[ ! -f "$changelog_file" ]]; then
+    echo ""
+    return
+  fi
+
+  awk -v ver="## $version" '
+    /^## / {
+      if (found) exit
+      if ($0 ~ ver) {
+        found=1
+        next
+      }
+    }
+    found { print }
+  ' "$changelog_file"
+}
+
+CHANGELOG_BODY="$(extract_changelog "$VERSION" "$CHANGELOG_FILE")"
+if [[ -z "$CHANGELOG_BODY" ]]; then
+  CHANGELOG_BODY="See commit history for details."
+fi
+
+PRERELEASE_FLAG="${GITEA_PRERELEASE:-false}"
+
+create_payload="$(jq -n \
+  --arg tag "$RELEASE_TAG" \
+  --arg name "iKeyMon ${VERSION}" \
+  --arg target "$TARGET_COMMIT" \
+  --arg body "$CHANGELOG_BODY" \
+  --argjson prerelease "$PRERELEASE_FLAG" \
+  '{ tag_name: $tag, name: $name, target_commitish: $target, body: $body, draft: false, prerelease: $prerelease }')"
+
+response_file="$(mktemp)"
+http_code=$(curl -sS -w "%{http_code}" -o "$response_file" \
+  -H "Authorization: token ${GITEA_TOKEN}" \
+  -H "Content-Type: application/json" \
+  -X POST \
+  -d "$create_payload" \
+  "${API_URL}/releases")
+
+if [[ "$http_code" == "201" ]]; then
+  echo "✅ Created release ${RELEASE_TAG}"
+elif [[ "$http_code" == "409" ]]; then
+  echo "ℹ️ Release ${RELEASE_TAG} already exists, fetching existing ID."
+else
+  echo "❌ Failed to create release (HTTP ${http_code}):"
+  cat "$response_file"
+  rm -f "$response_file"
+  exit 1
+fi
+
+if [[ "$http_code" == "409" ]]; then
+  curl -sS \
+    -H "Authorization: token ${GITEA_TOKEN}" \
+    "${API_URL}/releases/tags/${RELEASE_TAG}" >"$response_file"
+fi
+
+release_id=$(jq -r '.id' "$response_file")
+rm -f "$response_file"
+
+if [[ -z "$release_id" || "$release_id" == "null" ]]; then
+  echo "❌ Could not determine release ID for ${RELEASE_TAG}"
+  exit 1
+fi
+
+delete_existing_asset() {
+  local filename="$1"
+  local asset_id
+  asset_id="$(curl -sS \
+    -H "Authorization: token ${GITEA_TOKEN}" \
+    "${API_URL}/releases/${release_id}/assets" | jq -r --arg name "$filename" '.[] | select(.name == $name) | .id' | head -n 1)"
+  if [[ -n "$asset_id" && "$asset_id" != "null" ]]; then
+    echo "🗑️  Removing existing asset ${filename}"
+    curl -sS \
+      -H "Authorization: token ${GITEA_TOKEN}" \
+      -X DELETE \
+      "${API_URL}/releases/${release_id}/assets/${asset_id}" >/dev/null
+  fi
+}
+
+upload_asset() {
+  local file="$1"
+  local filename
+  filename="$(basename "$file")"
+
+  delete_existing_asset "$filename"
+
+  echo "⬆️  Uploading ${filename}"
+  curl -sS \
+    -H "Authorization: token ${GITEA_TOKEN}" \
+    -F "attachment=@${file}" \
+    "${API_URL}/releases/${release_id}/assets" >/dev/null
+}
+
+upload_asset "$ZIP_PATH"
+upload_asset "$DMG_PATH"
+
+echo "🎉 Release ${RELEASE_TAG} assets uploaded."

scripts/sync_version.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VERSION_FILE="$ROOT_DIR/version.json"
+PROJECT_FILE="$ROOT_DIR/iKeyMon.xcodeproj/project.pbxproj"
+
+if [[ ! -f "$VERSION_FILE" ]]; then
+  echo "❌ version.json not found at $VERSION_FILE" >&2
+  exit 1
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "❌ jq is required but not found in PATH" >&2
+  exit 1
+fi
+
+MARKETING_VERSION="$(jq -r '.marketing_version // empty' "$VERSION_FILE")"
+if [[ -z "$MARKETING_VERSION" ]]; then
+  echo "❌ marketing_version missing in $VERSION_FILE" >&2
+  exit 1
+fi
+
+if [[ ! "$MARKETING_VERSION" =~ ^[0-9]{2}\.[0-9]+\.[0-9]+$ ]]; then
+  echo "❌ marketing_version '$MARKETING_VERSION' must follow YY.major.minor (e.g. 26.1.2)" >&2
+  exit 1
+fi
+
+BUILD_NUMBER="${BUILD_NUMBER:-$(git -C "$ROOT_DIR" rev-list --count HEAD)}"
+if [[ -z "$BUILD_NUMBER" ]]; then
+  echo "❌ Unable to derive BUILD_NUMBER" >&2
+  exit 1
+fi
+
+update_setting() {
+  local key="$1"
+  local value="$2"
+  local tmp
+  tmp="$(mktemp)"
+  LC_ALL=C sed -E "s/(${key}[[:space:]]*=[[:space:]]*)[^;]+;/\\1${value};/g" "$PROJECT_FILE" >"$tmp"
+  if cmp -s "$tmp" "$PROJECT_FILE"; then
+    if ! grep -q "${key} = ${value};" "$PROJECT_FILE"; then
+      rm -f "$tmp"
+      echo "❌ Failed to update ${key} in $PROJECT_FILE" >&2
+      exit 1
+    fi
+    rm -f "$tmp"
+    return
+  fi
+  mv "$tmp" "$PROJECT_FILE"
+}
+
+update_setting "MARKETING_VERSION" "$MARKETING_VERSION"
+update_setting "CURRENT_PROJECT_VERSION" "$BUILD_NUMBER"
+
+echo "✅ Synced marketing version $MARKETING_VERSION and build $BUILD_NUMBER into Xcode project."

scripts/update_homebrew_tap.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+VERSION="${1:?usage: update_homebrew_tap.sh <version> <dmg_path>}"
+DMG_PATH="${2:?usage: update_homebrew_tap.sh <version> <dmg_path>}"
+TAP_DIR="${HOMEBREW_TAP_DIR:-$ROOT_DIR/homebrew-tap}"
+CASK_FILE="$TAP_DIR/Casks/ikeymon.rb"
+
+if [[ ! -d "$TAP_DIR/.git" ]]; then
+  echo "❌ Homebrew tap repo not found at $TAP_DIR"
+  exit 1
+fi
+
+if [[ ! -f "$CASK_FILE" ]]; then
+  echo "❌ Homebrew cask file not found at $CASK_FILE"
+  exit 1
+fi
+
+if [[ ! -f "$DMG_PATH" ]]; then
+  echo "❌ DMG artifact not found at $DMG_PATH"
+  exit 1
+fi
+
+if [[ -n "$(git -C "$TAP_DIR" status --porcelain)" ]]; then
+  echo "❌ Homebrew tap repo has uncommitted changes: $TAP_DIR"
+  exit 1
+fi
+
+SHA256="$(shasum -a 256 "$DMG_PATH" | awk '{print $1}')"
+
+python3 - <<'PY' "$CASK_FILE" "$VERSION" "$SHA256"
+from pathlib import Path
+import re
+import sys
+
+cask_path = Path(sys.argv[1])
+version = sys.argv[2]
+sha256 = sys.argv[3]
+content = cask_path.read_text(encoding="utf-8")
+
+content, version_count = re.subn(r'version "[^"]+"', f'version "{version}"', content, count=1)
+content, sha_count = re.subn(r'sha256 "[^"]+"', f'sha256 "{sha256}"', content, count=1)
+
+if version_count != 1 or sha_count != 1:
+    raise SystemExit("Failed to update version or sha256 in cask file")
+
+cask_path.write_text(content, encoding="utf-8")
+PY
+
+ruby -c "$CASK_FILE" >/dev/null
+
+if git -C "$TAP_DIR" diff --quiet -- "$CASK_FILE"; then
+  echo "ℹ️ Homebrew tap already points to iKeyMon ${VERSION}"
+  exit 0
+fi
+
+git -C "$TAP_DIR" add "$CASK_FILE"
+git -C "$TAP_DIR" commit -m "cask: update ikeymon to ${VERSION}"
+git -C "$TAP_DIR" push origin master
+
+echo "✅ Updated Homebrew tap to iKeyMon ${VERSION}"

signing.env.example

@@ -2,3 +2,15 @@ CODESIGN_IDENTITY="Developer ID Application: Your Name (TEAMID1234)"
 NOTARY_APPLE_ID="appleid@example.com"
 NOTARY_TEAM_ID="TEAMID1234"
 NOTARY_PASSWORD="app-specific-password"
+GITEA_TOKEN="personal-access-token"
+GITEA_OWNER="tracer"
+GITEA_REPO="iKeyMon"
+# GITEA_API_BASE="https://git.24unix.net/api/v1"
+# GITEA_TARGET_COMMIT="master"
+# GITEA_PRERELEASE="false"
+
+# Sparkle appcast generation (optional)
+# SPARKLE_EDDSA_KEY_FILE="$HOME/.config/Sparkle/iKeyMon.key"
+# SPARKLE_DOWNLOAD_BASE_TEMPLATE="https://git.24unix.net/tracer/iKeyMon/releases/download/v{{VERSION}}"
+# SPARKLE_APPCAST_OUTPUT="$ROOT_DIR/Sparkle/appcast.xml"  # defaults to this path
+# SPARKLE_GENERATE_APPCAST="/path/to/generate_appcast"  # auto-detected if unset

version.json

@@ -0,0 +1,3 @@
+{
+  "marketing_version": "26.1.7"
+}