chore: release 26.0.69

Disable app-sandbox to allow Sparkle auto-updates to work properly.
Keep entitlements file structure for future sandbox re-enablement.
Sandbox integration with Sparkle requires more complex authorization
setup that can be tackled later when preparing for App Store.

.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+xcuserdata/
+DerivedData/
+build/
+Build/
+dist/
+.signing.env

Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,51 +1,61 @@
 {
   "images" : [
     {
+      "filename" : "icon_16x16.png",
       "idiom" : "mac",
       "scale" : "1x",
       "size" : "16x16"
     },
     {
+      "filename" : "icon_16x16@2x.png",
       "idiom" : "mac",
       "scale" : "2x",
       "size" : "16x16"
     },
     {
+      "filename" : "icon_32x32.png",
       "idiom" : "mac",
       "scale" : "1x",
       "size" : "32x32"
     },
     {
+      "filename" : "icon_32x32@2x.png",
       "idiom" : "mac",
       "scale" : "2x",
       "size" : "32x32"
     },
     {
+      "filename" : "icon_128x128.png",
       "idiom" : "mac",
       "scale" : "1x",
       "size" : "128x128"
     },
     {
+      "filename" : "icon_128x128@2x.png",
       "idiom" : "mac",
       "scale" : "2x",
       "size" : "128x128"
     },
     {
+      "filename" : "icon_256x256.png",
       "idiom" : "mac",
       "scale" : "1x",
       "size" : "256x256"
     },
     {
+      "filename" : "icon_256x256@2x.png",
       "idiom" : "mac",
       "scale" : "2x",
       "size" : "256x256"
     },
     {
+      "filename" : "icon_512x512.png",
       "idiom" : "mac",
       "scale" : "1x",
       "size" : "512x512"
     },
     {
+      "filename" : "icon_512x512@2x.png",
       "idiom" : "mac",
       "scale" : "2x",
       "size" : "512x512"

CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## Unreleased
+
+### Fixed
+- Fixed Sparkle updater ZIP archive creation: replaced `zip` command with `ditto` to properly preserve app bundle code signatures during extraction, resolving "damaged app" errors on update installation.
+- Fixed code signature issues for sandboxed apps by removing entitlements parameter from non-sandboxed builds.
+- Fixed Sparkle framework deep code signing to handle complex framework structure.
+- Fixed missing XPC service entitlements (`com.apple.security.xpc.aConnectionServices`, `com.apple.security.xpc.aStatusServices`) required for Sparkle installer to communicate with sandboxed app.
+
+### Changed
+- Re-enabled app sandbox with minimal entitlements (network.client only) for improved security while maintaining Sparkle update functionality.
+- Enhanced Sparkle error logging to include error domain and code information, making update failures easier to diagnose.
+- Updated build script to use `ditto -c -k --keepParent` for creating update ZIPs, which properly preserves code signatures that `zip` command breaks.
+
+### Added
+- Added in-app Sparkle update logs in Preferences → Updates tab with Show/Hide toggle for real-time debugging of update operations.
+- Log entries include timestamps and distinguish between info and error messages.
+- Users can clear logs manually and logs persist during the session (max 100 entries).
+
+### 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

@@ -0,0 +1,9 @@
+- add tooltip for:
+    Ping (est time consideration)
+    dynamic Data
+    static Data
+
+add a marker for "reboot required"
+
+                    
+1112

README.md

@@ -8,9 +8,10 @@ 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
+- Built-in Sparkle updater (automatic checks, downloads, and relaunch once a signed release is available)
 - Organized layout using tabs: General / Resources / Services
 - Stores API keys securely in the macOS Keychain
 - Native macOS look & feel using SwiftUI
@@ -36,6 +37,80 @@ git clone https://git.24unix.net/tracer/iKeyMon
 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.
+
+To auto-publish the artifacts as a Gitea release, extend `.signing.env` with:
+
+```
+GITEA_TOKEN="..."
+GITEA_OWNER="tracer"
+GITEA_REPO="iKeyMon"
+# optional: GITEA_API_BASE="https://git.24unix.net/api/v1"
+# optional: GITEA_TARGET_COMMIT="master"
+# optional: GITEA_PRERELEASE="false"   # defaults to true until preferences are done
+# optional Sparkle feed helpers:
+# SPARKLE_EDDSA_KEY_FILE="$HOME/.config/Sparkle/iKeyMon.key"
+# SPARKLE_DOWNLOAD_BASE_TEMPLATE="https://git.24unix.net/tracer/iKeyMon/releases/download/v{{VERSION}}"
+# If you prefer SPARKLE_DOWNLOAD_BASE_URL, it will automatically append `/v<version>` for you.
+# SPARKLE_APPCAST_OUTPUT="$ROOT_DIR/Sparkle/appcast.xml"  # default
+```
+
+`GITEA_TARGET_COMMIT` defaults to the current `HEAD` commit, so overriding it lets you publish from another branch if needed. Whenever those variables are set, the script will create (or reuse) tag `v<version>` and upload both ZIP and DMG as release assets automatically.
+
+If you re-run the release script for the same version, it removes any existing assets with the same filenames before uploading, so you never end up with duplicate ZIP/DMG files on the release page.
+
+### Sparkle updates
+
+iKeyMon uses [Sparkle](https://sparkle-project.org/) for macOS-safe updates.
+
+1. Generate an EdDSA key pair once (`./Packages/Sparkle/bin/generate_keys`). Store the private key on-disk (for example `~/.config/Sparkle/iKeyMon.key`, which the build script expects) and copy the public key into the `SUPublicEDKey` entry (see Info.plist notes below).
+2. `./scripts/build_release.sh` signs the ZIP with Sparkle’s `sign_update` tool and invokes `generate_appcast` automatically when the Sparkle variables are present. The generated feed is written to `Sparkle/appcast.xml`, so commit that file after every release. Point `SPARKLE_DOWNLOAD_BASE_TEMPLATE` at your release-download prefix (e.g. `https://git.24unix.net/tracer/iKeyMon/releases/download/v{{VERSION}}`) so the generated URLs already match Gitea’s asset paths. The feed stays inside the repo (it is not uploaded as a release asset).
+3. Set `SUFeedURL` in Info.plist (or the corresponding build setting) to the raw URL of `Sparkle/appcast.xml` inside this repo (e.g. `https://git.24unix.net/tracer/iKeyMon/raw/branch/master/Sparkle/appcast.xml`).
+
+Preferences expose Sparkle’s built-in toggles for “Automatically check” and “Automatically download”, and the toolbar button simply calls Sparkle’s “Check for Updates…” sheet.
+
+> `./scripts/build_release.sh` will call `generate_appcast` for you when `SPARKLE_EDDSA_KEY_FILE` and `SPARKLE_DOWNLOAD_BASE_TEMPLATE` (or `SPARKLE_DOWNLOAD_BASE_URL`) are set. It tries to locate Sparkle’s CLI in DerivedData automatically, but you can override the path via `SPARKLE_GENERATE_APPCAST`. The resulting feed is written to `SPARKLE_APPCAST_OUTPUT` (defaults to `Sparkle/appcast.xml`).
+
+> Build settings include `INFOPLIST_KEY_SUFeedURL` and `INFOPLIST_KEY_SUPublicEDKey`. Make sure to fill both before shipping a build so Sparkle knows where to fetch updates and how to verify them.
+
+#### Debugging Sparkle updates
+
+Launch the shipped app via CLI with `SPARKLE_VERBOSE_LOGGING=1` to mirror Sparkle’s activity in stdout/stderr:
+
+```bash
+SPARKLE_VERBOSE_LOGGING=1 /Applications/iKeyMon.app/Contents/MacOS/iKeyMon
+```
+
+Sparkle’s installer helper runs in a separate `SUPipedBinary` process. If the installer fails, collect additional details with `log show --process SUPipedBinary --last 5m`.
+
+### Automated release push
+
+If you want `git push origin master` to build/sign/notarize/upload automatically, enable the provided pre-push hook:
+
+```bash
+git config core.hooksPath hooks
+```
+
+The hook (see `hooks/pre-push`) watches for pushes that include `refs/heads/master`, automatically bumps `marketing_version` (incrementing the last component), runs `scripts/build_release.sh`, stages `version.json`, `iKeyMon.xcodeproj/project.pbxproj`, and `Sparkle/appcast.xml`, then creates a commit `chore: release <version>`. It performs its own `git push` behind the scenes and cancels the original push command so you don't upload the same refs twice—once you see “Release … pushed. Original push cancelled”, you're done (Git will report the original push failed; that's expected). To skip the automation temporarily, prepend `SKIP_RELEASE=1` to your `git push` command.
+
+The bumping logic lives in `scripts/bump_version.sh` (feel free to run it manually if you need to create a release without pushing).
+
+### Versioning workflow
+
+- The canonical marketing version lives in `version.json` and follows the format `YY.major.minor` (example: `26.1.2`). Update that file manually whenever you cut a new release branch.
+- The build number is derived automatically from the git commit count on the current branch (you can override it by exporting `BUILD_NUMBER` before running the script if needed).
+- Run `./scripts/sync_version.sh` anytime after editing `version.json` (the release script already calls it). The helper updates `MARKETING_VERSION` and `CURRENT_PROJECT_VERSION` inside `iKeyMon.xcodeproj`, keeping Xcode, the app bundle, and release artifacts in sync.
+- `scripts/build_release.sh` reads the same `version.json` for naming the generated ZIP/DMG, so the artifact names, Info.plist values, and UI displays all stay aligned.
+
 ## 📦 License
 
 MIT — see [LICENSE](LICENSE) for details.

Sources/Extensions/View+Shimmer.swift

@@ -0,0 +1,50 @@
+import SwiftUI
+
+struct ShimmerModifier: ViewModifier {
+    var active: Bool
+    @State private var phase: CGFloat = -1
+
+    func body(content: Content) -> some View {
+        content
+            .overlay(
+                shimmer
+                    .mask(content)
+                    .opacity(active ? 1 : 0)
+            )
+            .onAppear {
+                guard active else { return }
+                animate()
+            }
+            .onChange(of: active) {
+                guard active else { return }
+                phase = -1
+                animate()
+            }
+    }
+
+    private var shimmer: some View {
+        LinearGradient(
+            gradient: Gradient(colors: [
+                .clear,
+                Color.white.opacity(0.6),
+                .clear
+            ]),
+            startPoint: .top,
+            endPoint: .bottom
+        )
+        .rotationEffect(.degrees(70))
+        .offset(x: phase * 250)
+    }
+
+    private func animate() {
+        withAnimation(.linear(duration: 1.2).repeatForever(autoreverses: false)) {
+            phase = 1
+        }
+    }
+}
+
+extension View {
+    func shimmering(active: Bool) -> some View {
+        modifier(ShimmerModifier(active: active))
+    }
+}

Sources/KeychainHelper.swift

@@ -9,7 +9,7 @@ import Foundation
 import Security
 
 enum KeychainHelper {
-    static func save(apiKey: String, for hostname: String) {
+    static func saveApiKey(_ apiKey: String, for hostname: String) {
         let data = Data(apiKey.utf8)
         let query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,

Sources/Model/API/ApiFactory.swift

@@ -0,0 +1,117 @@
+//
+//  ApiFactory.swift
+//  iKeyMon
+//
+//  Created by tracer on 13.11.25.
+//
+
+import Foundation
+
+enum APIVersion: String, CaseIterable {
+    case v2_12 = "2.12"
+    case v2_13 = "2.13"
+    
+    static func from(versionString: String) -> APIVersion? {
+        if let version = APIVersion(rawValue: versionString) {
+            return version
+        }
+        
+        let components = versionString.split(separator: ".").compactMap { Int($0) }
+        guard components.count >= 2 else { return nil }
+        
+        let major = components[0]
+        let minor = components[1]
+        
+        switch (major, minor) {
+        case (2, 12): return .v2_12
+        case (2, 13...): return .v2_13
+        default: return nil
+        }
+    }
+}
+
+protocol AnyServerAPI {
+    func fetchSystemInfo() async throws -> SystemInfo
+    func fetchLoadData() async throws -> Any
+    func fetchMemoryData() async throws -> Any
+    func fetchUtilizationData() async throws -> Any
+    func fetchServerSummary(apiKey: String) async throws -> ServerInfo
+}
+
+private struct AnyServerAPIWrapper<T: ServerAPIProtocol>: AnyServerAPI {
+    private let wrapped: T
+    
+    init(_ wrapped: T) {
+        self.wrapped = wrapped
+    }
+    
+    func fetchSystemInfo() async throws -> SystemInfo {
+        return try await wrapped.fetchSystemInfo()
+    }
+    
+    func fetchLoadData() async throws -> Any {
+        return try await wrapped.fetchLoad()
+    }
+    
+    func fetchMemoryData() async throws -> Any {
+        return try await wrapped.fetchMemory()
+    }
+    
+    func fetchUtilizationData() async throws -> Any {
+        return try await wrapped.fetchUtilization()
+    }
+
+    func fetchServerSummary(apiKey: String) async throws -> ServerInfo {
+        return try await wrapped.fetchServerSummary(apiKey: apiKey)
+    }
+}
+
+class APIFactory {
+    static func createAPI(baseURL: URL, version: APIVersion) -> AnyServerAPI {
+        switch version {
+        case .v2_12:
+            return AnyServerAPIWrapper(APIv2_12(baseURL: baseURL))
+        case .v2_13:
+            return AnyServerAPIWrapper(APIv2_13(baseURL: baseURL))
+        }
+    }
+    
+    static func createAPI(baseURL: URL, versionString: String) -> AnyServerAPI? {
+        guard let version = APIVersion.from(versionString: versionString) else { return nil }
+        return createAPI(baseURL: baseURL, version: version)
+    }
+    
+    static func detectAndCreateAPI(baseURL: URL, apiKey: String? = nil) async throws -> AnyServerAPI {
+        if let apiKey, !apiKey.isEmpty {
+            do {
+                let versionURL = baseURL.appendingPathComponent("api/v2/server")
+                var request = URLRequest(url: versionURL)
+                request.httpMethod = "GET"
+                request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
+                request.timeoutInterval = 15
+
+                let (data, response) = try await URLSession.shared.data(for: request)
+                if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
+                    let decoder = JSONDecoder()
+                    decoder.keyDecodingStrategy = .convertFromSnakeCase
+                    let probe = try decoder.decode(ServerMetaProbe.self, from: data)
+                    if let api = createAPI(baseURL: baseURL, versionString: probe.meta.apiVersion) {
+                        return api
+                    }
+                }
+            } catch {
+                // Fall back to default version below
+            }
+        }
+
+        return AnyServerAPIWrapper(APIv2_13(baseURL: baseURL))
+    }
+}
+
+private struct ServerMetaProbe: Decodable {
+    struct Meta: Decodable {
+        let apiVersion: String
+    }
+
+    let meta: Meta
+}

Sources/Model/API/ApiManager.swift

@@ -0,0 +1,64 @@
+//
+//  ApiManager.swift
+//  iKeyMon
+//
+//  Created by tracer on 13.11.25.
+//
+
+import Foundation
+import Combine
+
+@MainActor
+class APIManager: ObservableObject {
+    @Published var isConnected = false
+    @Published var currentVersion: String = ""
+    @Published var lastError: Error?
+    
+    private var api: AnyServerAPI?
+    private let baseURL: URL
+    
+    init(baseURL: URL) {
+        self.baseURL = baseURL
+    }
+    
+    func connect() async {
+        do {
+            self.api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL)
+            let systemInfo = try await api!.fetchSystemInfo()
+            self.currentVersion = systemInfo.version
+            self.isConnected = true
+            self.lastError = nil
+        } catch {
+            self.isConnected = false
+            self.lastError = error
+            self.api = nil
+        }
+    }
+    
+    func disconnect() {
+        self.api = nil
+        self.isConnected = false
+        self.currentVersion = ""
+        self.lastError = nil
+    }
+    
+    func fetchSystemInfo() async throws -> SystemInfo {
+        guard let api = api else { throw APIError.invalidResponse }
+        return try await api.fetchSystemInfo()
+    }
+    
+    func fetchLoad() async throws -> Any {
+        guard let api = api else { throw APIError.invalidResponse }
+        return try await api.fetchLoadData()
+    }
+    
+    func fetchMemory() async throws -> Any {
+        guard let api = api else { throw APIError.invalidResponse }
+        return try await api.fetchMemoryData()
+    }
+    
+    func fetchUtilization() async throws -> Any {
+        guard let api = api else { throw APIError.invalidResponse }
+        return try await api.fetchUtilizationData()
+    }
+}

Sources/Model/API/BaseAPI.swift

@@ -0,0 +1,67 @@
+//
+//  BaseAPI.swift
+//  iKeyMon
+//
+//  Created by tracer on 13.11.25.
+//
+
+
+import Foundation
+
+protocol ServerAPIProtocol {
+    associatedtype LoadType: Codable
+    associatedtype MemoryType: Codable
+    associatedtype UtilizationType: Codable
+    
+    func fetchSystemInfo() async throws -> SystemInfo
+    func fetchLoad() async throws -> LoadType
+    func fetchMemory() async throws -> MemoryType
+    func fetchUtilization() async throws -> UtilizationType
+    func fetchServerSummary(apiKey: String) async throws -> ServerInfo
+}
+
+struct SystemInfo: Codable {
+    let version: String
+    let timestamp: Date
+    let hostname: String
+}
+
+class BaseAPIClient {
+    let baseURL: URL
+    let session: URLSession
+    
+    init(baseURL: URL, session: URLSession = .shared) {
+        self.baseURL = baseURL
+        self.session = session
+    }
+    
+    func performRequest<T: Codable>(_ request: URLRequest, responseType: T.Type) async throws -> T {
+        let (data, response) = try await session.data(for: request)
+        
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw APIError.invalidResponse
+        }
+        
+        guard 200...299 ~= httpResponse.statusCode else {
+            throw APIError.httpError(httpResponse.statusCode)
+        }
+        
+        return try JSONDecoder().decode(T.self, from: data)
+    }
+}
+
+enum APIError: Error, LocalizedError {
+    case invalidURL
+    case invalidResponse
+    case httpError(Int)
+    case decodingError(Error)
+    
+    var errorDescription: String? {
+        switch self {
+        case .invalidURL: return "Invalid URL"
+        case .invalidResponse: return "Invalid response"
+        case .httpError(let code): return "HTTP Error: \(code)"
+        case .decodingError(let error): return "Decoding error: \(error.localizedDescription)"
+        }
+    }
+}

Sources/Model/API/PingService.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+enum PingService {
+    static func ping(hostname: String, apiKey: String) async -> Bool {
+        guard let url = URL(string: "https://\(hostname)/api/v2/ping") else {
+            print("❌ [PingService] Invalid URL for \(hostname)")
+            return false
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
+        request.timeoutInterval = 10
+
+        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)")
+                }
+                return false
+            }
+
+            if let result = try? JSONDecoder().decode([String: String].self, from: data), result["response"] == "pong" {
+                return true
+            } else {
+                return false
+            }
+        } catch {
+            print("❌ [PingService] Error pinging \(hostname): \(error)")
+            return false
+        }
+    }
+}

Sources/Model/API/Server.swift

@@ -0,0 +1,55 @@
+//
+//  Server.swift
+//  iKeyMon
+//
+//  Created by tracer on 30.03.25.
+//
+
+import Foundation
+
+struct Server: Identifiable, Codable, Hashable, Equatable {
+    let id: UUID
+    var hostname: String
+    var info: ServerInfo?
+    var pingable: Bool
+
+    init(id: UUID = UUID(), hostname: String, info: ServerInfo? = nil, pingable: Bool = false) {
+        self.id = id
+        self.hostname = hostname
+        self.info = info
+        self.pingable = pingable
+    }
+
+    // MARK: - Manual conformance
+
+    static func == (lhs: Server, rhs: Server) -> Bool {
+        lhs.id == rhs.id && lhs.hostname == rhs.hostname && lhs.info == rhs.info && lhs.pingable == rhs.pingable
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+        hasher.combine(hostname)
+        hasher.combine(info)
+        hasher.combine(pingable)
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case id, hostname, info, pingable
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        id = try container.decode(UUID.self, forKey: .id)
+        hostname = try container.decode(String.self, forKey: .hostname)
+        info = try container.decodeIfPresent(ServerInfo.self, forKey: .info)
+        pingable = try container.decodeIfPresent(Bool.self, forKey: .pingable) ?? false
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(id, forKey: .id)
+        try container.encode(hostname, forKey: .hostname)
+        try container.encodeIfPresent(info, forKey: .info)
+        try container.encode(pingable, forKey: .pingable)
+    }
+}

Sources/Model/API/ServerInfo.swift

@@ -0,0 +1,270 @@
+import Foundation
+
+// MARK: - Server Info Domain Model
+
+struct ServerInfo: Codable, Hashable, Equatable {
+    struct Load: Codable, Hashable, Equatable {
+        let minute1: Double
+        let minute5: Double
+        let minute15: Double
+        let percent: Double
+        let cpuCount: Int
+        let level: String
+
+        init(minute1: Double, minute5: Double, minute15: Double, percent: Double, cpuCount: Int, level: String) {
+            self.minute1 = minute1
+            self.minute5 = minute5
+            self.minute15 = minute15
+            self.percent = percent
+            self.cpuCount = cpuCount
+            self.level = level
+        }
+    }
+
+    struct Memory: Codable, Hashable, Equatable {
+        let free: Int
+        let used: Int
+        let total: Int
+        let percent: Double
+
+        init(free: Int, used: Int, total: Int, percent: Double) {
+            self.free = free
+            self.used = used
+            self.total = total
+            self.percent = percent
+        }
+    }
+
+    struct DiskSpace: Codable, Hashable, Equatable {
+        let free: Int
+        let used: Int
+        let total: Int
+        let percent: Double
+
+        init(free: Int, used: Int, total: Int, percent: Double) {
+            self.free = free
+            self.used = used
+            self.total = total
+            self.percent = percent
+        }
+    }
+
+    struct ServicePort: Codable, Hashable, Identifiable, Equatable {
+        var id: String { "\(service)-\(port)-\(proto)" }
+        let service: String
+        let status: String
+        let port: Int
+        let proto: String
+
+        init(service: String, status: String, port: Int, proto: String) {
+            self.service = service
+            self.status = status
+            self.port = port
+            self.proto = proto
+        }
+    }
+
+    struct PHPInterpreter: Codable, Hashable, Identifiable, Equatable {
+        var id: String { [fullVersion, path ?? ""].joined(separator: "|") }
+        let version: String
+        let fullVersion: String
+        let path: String?
+        let configFile: String?
+        let extensions: [String]
+        let memoryLimit: String?
+        let maxExecutionTime: String?
+
+        init(
+            version: String,
+            fullVersion: String? = nil,
+            path: String? = nil,
+            configFile: String? = nil,
+            extensions: [String] = [],
+            memoryLimit: String? = nil,
+            maxExecutionTime: String? = nil
+        ) {
+            self.version = version
+            self.fullVersion = fullVersion ?? version
+            self.path = path
+            self.configFile = configFile
+            self.extensions = extensions
+            self.memoryLimit = memoryLimit
+            self.maxExecutionTime = maxExecutionTime
+        }
+
+        var versionWithPath: String {
+            var components = [fullVersion]
+            if let path, !path.isEmpty {
+                components.append(path)
+            }
+            return components.joined(separator: " – ")
+        }
+    }
+
+    struct OperatingSystem: Codable, Hashable, Equatable {
+        struct UpdateStatus: Codable, Hashable, Equatable {
+            let updateCount: Int
+            let securityUpdateCount: Int
+            let rebootRequired: Bool
+
+            init(updateCount: Int, securityUpdateCount: Int, rebootRequired: Bool) {
+                self.updateCount = updateCount
+                self.securityUpdateCount = securityUpdateCount
+                self.rebootRequired = rebootRequired
+            }
+        }
+
+        let label: String
+        let distribution: String
+        let version: String
+        let architecture: String
+        let endOfLife: Bool
+        let updates: UpdateStatus?
+
+        init(
+            label: String,
+            distribution: String,
+            version: String,
+            architecture: String,
+            endOfLife: Bool,
+            updates: UpdateStatus?
+        ) {
+            self.label = label
+            self.distribution = distribution
+            self.version = version
+            self.architecture = architecture
+            self.endOfLife = endOfLife
+            self.updates = updates
+        }
+    }
+
+    var hostname: String
+    var ipAddresses: [String]
+    var cpuCores: Int
+    var serverTime: String
+    var uptime: String
+    var processCount: Int
+    var apacheVersion: String
+    var phpVersion: String
+    var mysqlVersion: String?
+    var mariadbVersion: String?
+    var emailsInQueue: Int?
+    var operatingSystem: OperatingSystem?
+    var ports: [ServicePort]?
+    var load: Load
+    var memory: Memory
+    var swap: Memory
+    var diskSpace: DiskSpace
+    var panelVersion: String
+    var panelBuild: String
+    var apiVersion: String
+    var additionalPHPInterpreters: [PHPInterpreter]?
+
+    var formattedVersion: String {
+        "KeyHelp \(panelVersion) • Build \(panelBuild) • API \(apiVersion)"
+    }
+
+    var formattedServerTime: String {
+        let normalizedServerTime = ServerInfo.normalizedServerTime(serverTime)
+
+        if let date = ServerInfo.serverTimeParsers
+            .lazy
+            .compactMap({ $0.date(from: normalizedServerTime) })
+            .first {
+            return ServerInfo.displayFormatter.string(from: date)
+        }
+
+        return serverTime
+    }
+
+    var operatingSystemSummary: String? {
+        guard let operatingSystem else { return nil }
+        let components = [
+            operatingSystem.label,
+            operatingSystem.architecture
+        ].filter { !$0.isEmpty }
+        return components.isEmpty ? nil : components.joined(separator: " • ")
+    }
+}
+
+// MARK: - Helpers & Sample Data
+
+extension ServerInfo {
+    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
+    }
+
+    static let placeholder = ServerInfo(
+        hostname: "preview.example.com",
+        ipAddresses: ["192.168.1.1", "fe80::1"],
+        cpuCores: 4,
+        serverTime: "2025-04-04T18:00:00+0200",
+        uptime: "3 Days / 12 Hours / 30 Minutes",
+        processCount: 123,
+        apacheVersion: "2.4.58",
+        phpVersion: "8.2.12",
+        mysqlVersion: "8.0.33",
+        mariadbVersion: nil,
+        emailsInQueue: 0,
+        operatingSystem: OperatingSystem(
+            label: "Debian 12.12 (64-bit)",
+            distribution: "Debian",
+            version: "12.12",
+            architecture: "x86_64",
+            endOfLife: false,
+            updates: OperatingSystem.UpdateStatus(
+                updateCount: 12,
+                securityUpdateCount: 8,
+                rebootRequired: true
+            )
+        ),
+        ports: [
+            ServicePort(service: "HTTP", status: "online", port: 80, proto: "tcp"),
+            ServicePort(service: "HTTPS", status: "online", port: 443, proto: "tcp"),
+            ServicePort(service: "SSH", status: "offline", port: 22, proto: "tcp")
+        ],
+        load: Load(minute1: 0.5, minute5: 0.3, minute15: 0.2, percent: 10.0, cpuCount: 4, level: "low"),
+        memory: Memory(free: 8_000_000_000, used: 4_000_000_000, total: 12_000_000_000, percent: 33.3),
+        swap: Memory(free: 4_000_000_000, used: 1_000_000_000, total: 5_000_000_000, percent: 20.0),
+        diskSpace: DiskSpace(free: 100_000_000_000, used: 50_000_000_000, total: 150_000_000_000, percent: 33.3),
+        panelVersion: "25.0",
+        panelBuild: "3394",
+        apiVersion: "2",
+        additionalPHPInterpreters: [
+            PHPInterpreter(version: "8.3", path: "/usr/bin/php8.3"),
+            PHPInterpreter(version: "8.2", path: "/usr/bin/php8.2")
+        ]
+    )
+}

Sources/Model/API/Versions/APIv2_12.swift

@@ -0,0 +1,413 @@
+//
+//  APIv2_12.swift
+//  iKeyMon
+//
+//  Created by tracer on 13.11.25.
+//
+
+
+import Foundation
+
+extension APIv2_12 {
+    struct Load: Codable {
+        let current: LoadMetrics
+        let historical: [LoadMetrics]
+        
+        struct LoadMetrics: Codable {
+            let oneMinute: Double
+            let fiveMinute: Double
+            let fifteenMinute: Double
+            let timestamp: Date
+            
+            enum CodingKeys: String, CodingKey {
+                case oneMinute = "load_1"
+                case fiveMinute = "load_5"
+                case fifteenMinute = "load_15"
+                case timestamp
+            }
+        }
+    }
+    
+    struct Memory: Codable {
+        let system: SystemMemory
+        let swap: SwapMemory?
+        
+        struct SystemMemory: Codable {
+            let total: Int64
+            let used: Int64
+            let free: Int64
+            let available: Int64
+            let buffers: Int64?
+            let cached: Int64?
+        }
+        
+        struct SwapMemory: Codable {
+            let total: Int64
+            let used: Int64
+            let free: Int64
+        }
+    }
+    
+    struct Utilization: Codable {
+        let cpu: CPUUtilization
+        let memory: MemoryUtilization
+        let disk: [DiskUtilization]
+        let network: [NetworkUtilization]?
+        
+        struct CPUUtilization: Codable {
+            let overall: Double
+            let cores: [Double]
+            let processes: [ProcessInfo]?
+            
+            struct ProcessInfo: Codable {
+                let pid: Int
+                let name: String
+                let cpuPercent: Double
+                
+                enum CodingKeys: String, CodingKey {
+                    case pid
+                    case name
+                    case cpuPercent = "cpu_percent"
+                }
+            }
+        }
+        
+        struct MemoryUtilization: Codable {
+            let percent: Double
+            let topProcesses: [ProcessMemoryInfo]?
+            
+            struct ProcessMemoryInfo: Codable {
+                let pid: Int
+                let name: String
+                let memoryMB: Double
+                
+                enum CodingKeys: String, CodingKey {
+                    case pid
+                    case name
+                    case memoryMB = "memory_mb"
+                }
+            }
+        }
+        
+        struct DiskUtilization: Codable {
+            let device: String
+            let mountpoint: String
+            let usedPercent: Double
+            let totalBytes: Int64
+            let usedBytes: Int64
+            let freeBytes: Int64
+            
+            enum CodingKeys: String, CodingKey {
+                case device
+                case mountpoint
+                case usedPercent = "used_percent"
+                case totalBytes = "total_bytes"
+                case usedBytes = "used_bytes"
+                case freeBytes = "free_bytes"
+            }
+        }
+        
+        struct NetworkUtilization: Codable {
+            let interface: String
+            let bytesIn: Int64
+            let bytesOut: Int64
+            let packetsIn: Int64
+            let packetsOut: Int64
+            
+            enum CodingKeys: String, CodingKey {
+                case interface
+                case bytesIn = "bytes_in"
+                case bytesOut = "bytes_out"
+                case packetsIn = "packets_in"
+                case packetsOut = "packets_out"
+            }
+        }
+    }
+}
+
+class APIv2_12: BaseAPIClient, ServerAPIProtocol {
+    typealias LoadType = APIv2_12.Load
+    typealias MemoryType = APIv2_12.Memory
+    typealias UtilizationType = APIv2_12.Utilization
+    
+    private enum Endpoint: String {
+        case systemInfo = "/api/v2/system/info"
+        case load = "/api/v2/metrics/load"
+        case memory = "/api/v2/metrics/memory"
+        case utilization = "/api/v2/metrics/utilization"
+        
+        func url(baseURL: URL) -> URL {
+            return baseURL.appendingPathComponent(self.rawValue)
+        }
+    }
+    
+    func fetchSystemInfo() async throws -> SystemInfo {
+        let url = Endpoint.systemInfo.url(baseURL: baseURL)
+        let request = URLRequest(url: url)
+        return try await performRequest(request, responseType: SystemInfo.self)
+    }
+    
+    func fetchLoad() async throws -> LoadType {
+        let url = Endpoint.load.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: LoadType.self)
+    }
+    
+    func fetchMemory() async throws -> MemoryType {
+        let url = Endpoint.memory.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: MemoryType.self)
+    }
+    
+    func fetchUtilization() async throws -> UtilizationType {
+        let url = Endpoint.utilization.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: UtilizationType.self)
+    }
+
+    func fetchServerSummary(apiKey: String) async throws -> ServerInfo {
+        let summaryURL = baseURL.appendingPathComponent("api/v2/server")
+        var request = URLRequest(url: summaryURL)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
+        request.timeoutInterval = 30
+
+        let (data, response) = try await session.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw APIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            throw APIError.httpError(httpResponse.statusCode)
+        }
+
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        let envelope = try decoder.decode(ServerSummaryEnvelope.self, from: data)
+        return envelope.toDomain()
+    }
+}
+
+// MARK: - Server Summary Mapping
+
+private extension APIv2_12 {
+    struct ServerSummaryEnvelope: Decodable {
+        let meta: Meta
+        let operatingSystem: OperatingSystem?
+        let utilization: Utilization
+        let components: Components
+        let ports: [Port]?
+        let additionalPhpInterpreters: [AdditionalInterpreter]?
+
+        struct Meta: Decodable {
+            struct Uptime: Decodable {
+                let days: Int
+                let hours: Int
+                let minutes: Int
+                let seconds: Int
+
+                var formatted: String {
+                    "\(days) Days / \(hours) Hours / \(minutes) Minutes / \(seconds) Seconds"
+                }
+            }
+
+            let hostname: String
+            let ipAddresses: [String]
+            let serverTime: String
+            let uptime: Uptime
+            let panelVersion: String
+            let panelBuild: Int
+            let apiVersion: String
+        }
+
+        struct Utilization: Decodable {
+            struct Load: Decodable {
+                let minute1: Double
+                let minute5: Double
+                let minute15: Double
+                let cpuCount: Int
+                let percent: Double
+                let level: String
+            }
+
+            struct Memory: Decodable {
+                let free: Int
+                let used: Int
+                let total: Int
+                let percent: Double
+            }
+
+            struct Disk: Decodable {
+                let free: Int
+                let used: Int
+                let total: Int
+                let percent: Double
+            }
+
+            let processCount: Int
+            let emailsInQueue: Int?
+            let load: Load
+            let diskSpace: Disk
+            let memory: Memory
+            let swap: Memory
+        }
+
+        struct Components: Decodable {
+            let apache: String
+            let php: String
+            let mysql: String?
+            let mariadb: String?
+        }
+
+        struct Port: Decodable {
+            let service: String
+            let status: String
+            let port: Int
+            let proto: String
+
+            enum CodingKeys: String, CodingKey {
+                case service
+                case status
+                case port
+                case proto = "protocol"
+            }
+        }
+
+        struct AdditionalInterpreter: Decodable {
+            let version: String
+            let versionFull: String?
+            let path: String?
+            let configFile: String?
+        }
+        
+        struct OperatingSystem: Decodable {
+            struct Updates: Decodable {
+                let updateCount: Int
+                let securityUpdateCount: Int
+                let rebootRequired: Bool
+
+                enum CodingKeys: String, CodingKey {
+                    case updateCount = "update_count"
+                    case securityUpdateCount = "security_update_count"
+                    case rebootRequired = "reboot_required"
+                }
+
+                init(from decoder: Decoder) throws {
+                    let container = try decoder.container(keyedBy: CodingKeys.self)
+                    updateCount = try container.decodeIfPresent(Int.self, forKey: .updateCount) ?? 0
+                    securityUpdateCount = try container.decodeIfPresent(Int.self, forKey: .securityUpdateCount) ?? 0
+                    rebootRequired = try container.decodeIfPresent(Bool.self, forKey: .rebootRequired) ?? false
+                }
+            }
+
+            let label: String
+            let distribution: String
+            let version: String
+            let architecture: String
+            let endOfLife: Bool
+            let updates: Updates?
+
+            enum CodingKeys: String, CodingKey {
+                case label
+                case distribution
+                case version
+                case architecture
+                case endOfLife = "end_of_life"
+                case updates
+            }
+
+            init(from decoder: Decoder) throws {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                label = try container.decodeIfPresent(String.self, forKey: .label) ?? ""
+                distribution = try container.decodeIfPresent(String.self, forKey: .distribution) ?? ""
+                version = try container.decodeIfPresent(String.self, forKey: .version) ?? ""
+                architecture = try container.decodeIfPresent(String.self, forKey: .architecture) ?? ""
+                endOfLife = try container.decodeIfPresent(Bool.self, forKey: .endOfLife) ?? false
+                updates = try container.decodeIfPresent(Updates.self, forKey: .updates)
+            }
+        }
+
+        func toDomain() -> ServerInfo {
+            let load = utilization.load
+            let disk = utilization.diskSpace
+            let memory = utilization.memory
+            let swapMemory = utilization.swap
+
+            return ServerInfo(
+                hostname: meta.hostname,
+                ipAddresses: meta.ipAddresses,
+                cpuCores: load.cpuCount,
+                serverTime: meta.serverTime,
+                uptime: meta.uptime.formatted,
+                processCount: utilization.processCount,
+                apacheVersion: components.apache,
+                phpVersion: components.php,
+                mysqlVersion: components.mysql,
+                mariadbVersion: components.mariadb,
+                emailsInQueue: utilization.emailsInQueue,
+                operatingSystem: operatingSystem.map {
+                    ServerInfo.OperatingSystem(
+                        label: $0.label,
+                        distribution: $0.distribution,
+                        version: $0.version,
+                        architecture: $0.architecture,
+                        endOfLife: $0.endOfLife,
+                        updates: $0.updates.map {
+                            ServerInfo.OperatingSystem.UpdateStatus(
+                                updateCount: $0.updateCount,
+                                securityUpdateCount: $0.securityUpdateCount,
+                                rebootRequired: $0.rebootRequired
+                            )
+                        }
+                    )
+                },
+                ports: ports?.map {
+                    ServerInfo.ServicePort(service: $0.service, status: $0.status, port: $0.port, proto: $0.proto)
+                },
+                load: ServerInfo.Load(
+                    minute1: load.minute1,
+                    minute5: load.minute5,
+                    minute15: load.minute15,
+                    percent: load.percent,
+                    cpuCount: load.cpuCount,
+                    level: load.level
+                ),
+                memory: ServerInfo.Memory(
+                    free: memory.free,
+                    used: memory.used,
+                    total: memory.total,
+                    percent: memory.percent
+                ),
+                swap: ServerInfo.Memory(
+                    free: swapMemory.free,
+                    used: swapMemory.used,
+                    total: swapMemory.total,
+                    percent: swapMemory.percent
+                ),
+                diskSpace: ServerInfo.DiskSpace(
+                    free: disk.free,
+                    used: disk.used,
+                    total: disk.total,
+                    percent: disk.percent
+                ),
+                panelVersion: meta.panelVersion,
+                panelBuild: String(meta.panelBuild),
+                apiVersion: meta.apiVersion,
+                additionalPHPInterpreters: additionalPhpInterpreters?.map {
+                    ServerInfo.PHPInterpreter(
+                        version: $0.version,
+                        fullVersion: $0.versionFull,
+                        path: $0.path,
+                        configFile: $0.configFile,
+                        extensions: [],
+                        memoryLimit: nil,
+                        maxExecutionTime: nil
+                    )
+                }
+            )
+        }
+    }
+}

Sources/Model/API/Versions/APIv2_13.swift

@@ -0,0 +1,413 @@
+//
+//  APIv2_13.swift
+//  iKeyMon
+//
+//  Created by tracer on 13.11.25.
+//
+
+
+import Foundation
+
+extension APIv2_13 {
+    struct Load: Codable {
+        let current: LoadMetrics
+        let historical: [LoadMetrics]
+        
+        struct LoadMetrics: Codable {
+            let oneMinute: Double
+            let fiveMinute: Double
+            let fifteenMinute: Double
+            let timestamp: Date
+            
+            enum CodingKeys: String, CodingKey {
+                case oneMinute = "load_1"
+                case fiveMinute = "load_5"
+                case fifteenMinute = "load_15"
+                case timestamp
+            }
+        }
+    }
+    
+    struct Memory: Codable {
+        let system: SystemMemory
+        let swap: SwapMemory?
+        
+        struct SystemMemory: Codable {
+            let total: Int64
+            let used: Int64
+            let free: Int64
+            let available: Int64
+            let buffers: Int64?
+            let cached: Int64?
+        }
+        
+        struct SwapMemory: Codable {
+            let total: Int64
+            let used: Int64
+            let free: Int64
+        }
+    }
+    
+    struct Utilization: Codable {
+        let cpu: CPUUtilization
+        let memory: MemoryUtilization
+        let disk: [DiskUtilization]
+        let network: [NetworkUtilization]?
+        
+        struct CPUUtilization: Codable {
+            let overall: Double
+            let cores: [Double]
+            let processes: [ProcessInfo]?
+            
+            struct ProcessInfo: Codable {
+                let pid: Int
+                let name: String
+                let cpuPercent: Double
+                
+                enum CodingKeys: String, CodingKey {
+                    case pid
+                    case name
+                    case cpuPercent = "cpu_percent"
+                }
+            }
+        }
+        
+        struct MemoryUtilization: Codable {
+            let percent: Double
+            let topProcesses: [ProcessMemoryInfo]?
+            
+            struct ProcessMemoryInfo: Codable {
+                let pid: Int
+                let name: String
+                let memoryMB: Double
+                
+                enum CodingKeys: String, CodingKey {
+                    case pid
+                    case name
+                    case memoryMB = "memory_mb"
+                }
+            }
+        }
+        
+        struct DiskUtilization: Codable {
+            let device: String
+            let mountpoint: String
+            let usedPercent: Double
+            let totalBytes: Int64
+            let usedBytes: Int64
+            let freeBytes: Int64
+            
+            enum CodingKeys: String, CodingKey {
+                case device
+                case mountpoint
+                case usedPercent = "used_percent"
+                case totalBytes = "total_bytes"
+                case usedBytes = "used_bytes"
+                case freeBytes = "free_bytes"
+            }
+        }
+        
+        struct NetworkUtilization: Codable {
+            let interface: String
+            let bytesIn: Int64
+            let bytesOut: Int64
+            let packetsIn: Int64
+            let packetsOut: Int64
+            
+            enum CodingKeys: String, CodingKey {
+                case interface
+                case bytesIn = "bytes_in"
+                case bytesOut = "bytes_out"
+                case packetsIn = "packets_in"
+                case packetsOut = "packets_out"
+            }
+        }
+    }
+}
+
+class APIv2_13: BaseAPIClient, ServerAPIProtocol {
+    typealias LoadType = APIv2_13.Load
+    typealias MemoryType = APIv2_13.Memory
+    typealias UtilizationType = APIv2_13.Utilization
+    
+    private enum Endpoint: String {
+        case systemInfo = "/api/v2/system/info"
+        case load = "/api/v2/metrics/load"
+        case memory = "/api/v2/metrics/memory"
+        case utilization = "/api/v2/metrics/utilization"
+        
+        func url(baseURL: URL) -> URL {
+            return baseURL.appendingPathComponent(self.rawValue)
+        }
+    }
+    
+    func fetchSystemInfo() async throws -> SystemInfo {
+        let url = Endpoint.systemInfo.url(baseURL: baseURL)
+        let request = URLRequest(url: url)
+        return try await performRequest(request, responseType: SystemInfo.self)
+    }
+    
+    func fetchLoad() async throws -> LoadType {
+        let url = Endpoint.load.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: LoadType.self)
+    }
+    
+    func fetchMemory() async throws -> MemoryType {
+        let url = Endpoint.memory.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: MemoryType.self)
+    }
+    
+    func fetchUtilization() async throws -> UtilizationType {
+        let url = Endpoint.utilization.url(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return try await performRequest(request, responseType: UtilizationType.self)
+    }
+
+    func fetchServerSummary(apiKey: String) async throws -> ServerInfo {
+        let summaryURL = baseURL.appendingPathComponent("api/v2/server")
+        var request = URLRequest(url: summaryURL)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
+        request.timeoutInterval = 30
+
+        let (data, response) = try await session.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw APIError.invalidResponse
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            throw APIError.httpError(httpResponse.statusCode)
+        }
+
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        let envelope = try decoder.decode(ServerSummaryEnvelope.self, from: data)
+        return envelope.toDomain()
+    }
+}
+
+// MARK: - Server Summary Mapping
+
+private extension APIv2_13 {
+    struct ServerSummaryEnvelope: Decodable {
+        let meta: Meta
+        let operatingSystem: OperatingSystem?
+        let utilization: Utilization
+        let components: Components
+        let ports: [Port]?
+        let additionalPhpInterpreters: [AdditionalInterpreter]?
+
+        struct Meta: Decodable {
+            struct Uptime: Decodable {
+                let days: Int
+                let hours: Int
+                let minutes: Int
+                let seconds: Int
+
+                var formatted: String {
+                    "\(days) Days / \(hours) Hours / \(minutes) Minutes / \(seconds) Seconds"
+                }
+            }
+
+            let hostname: String
+            let ipAddresses: [String]
+            let serverTime: String
+            let uptime: Uptime
+            let panelVersion: String
+            let panelBuild: Int
+            let apiVersion: String
+        }
+
+        struct Utilization: Decodable {
+            struct Load: Decodable {
+                let minute1: Double
+                let minute5: Double
+                let minute15: Double
+                let cpuCount: Int
+                let percent: Double
+                let level: String
+            }
+
+            struct Memory: Decodable {
+                let free: Int
+                let used: Int
+                let total: Int
+                let percent: Double
+            }
+
+            struct Disk: Decodable {
+                let free: Int
+                let used: Int
+                let total: Int
+                let percent: Double
+            }
+
+            let processCount: Int
+            let emailsInQueue: Int?
+            let load: Load
+            let diskSpace: Disk
+            let memory: Memory
+            let swap: Memory
+        }
+
+        struct Components: Decodable {
+            let apache: String
+            let php: String
+            let mysql: String?
+            let mariadb: String?
+        }
+
+        struct Port: Decodable {
+            let service: String
+            let status: String
+            let port: Int
+            let proto: String
+
+            enum CodingKeys: String, CodingKey {
+                case service
+                case status
+                case port
+                case proto = "protocol"
+            }
+        }
+
+        struct AdditionalInterpreter: Decodable {
+            let version: String
+            let versionFull: String?
+            let path: String?
+            let configFile: String?
+        }
+        
+        struct OperatingSystem: Decodable {
+            struct Updates: Decodable {
+                let updateCount: Int
+                let securityUpdateCount: Int
+                let rebootRequired: Bool
+
+                enum CodingKeys: String, CodingKey {
+                    case updateCount = "update_count"
+                    case securityUpdateCount = "security_update_count"
+                    case rebootRequired = "reboot_required"
+                }
+
+                init(from decoder: Decoder) throws {
+                    let container = try decoder.container(keyedBy: CodingKeys.self)
+                    updateCount = try container.decodeIfPresent(Int.self, forKey: .updateCount) ?? 0
+                    securityUpdateCount = try container.decodeIfPresent(Int.self, forKey: .securityUpdateCount) ?? 0
+                    rebootRequired = try container.decodeIfPresent(Bool.self, forKey: .rebootRequired) ?? false
+                }
+            }
+
+            let label: String
+            let distribution: String
+            let version: String
+            let architecture: String
+            let endOfLife: Bool
+            let updates: Updates?
+
+            enum CodingKeys: String, CodingKey {
+                case label
+                case distribution
+                case version
+                case architecture
+                case endOfLife = "end_of_life"
+                case updates
+            }
+
+            init(from decoder: Decoder) throws {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                label = try container.decodeIfPresent(String.self, forKey: .label) ?? ""
+                distribution = try container.decodeIfPresent(String.self, forKey: .distribution) ?? ""
+                version = try container.decodeIfPresent(String.self, forKey: .version) ?? ""
+                architecture = try container.decodeIfPresent(String.self, forKey: .architecture) ?? ""
+                endOfLife = try container.decodeIfPresent(Bool.self, forKey: .endOfLife) ?? false
+                updates = try container.decodeIfPresent(Updates.self, forKey: .updates)
+            }
+        }
+
+        func toDomain() -> ServerInfo {
+            let load = utilization.load
+            let disk = utilization.diskSpace
+            let memory = utilization.memory
+            let swapMemory = utilization.swap
+
+            return ServerInfo(
+                hostname: meta.hostname,
+                ipAddresses: meta.ipAddresses,
+                cpuCores: load.cpuCount,
+                serverTime: meta.serverTime,
+                uptime: meta.uptime.formatted,
+                processCount: utilization.processCount,
+                apacheVersion: components.apache,
+                phpVersion: components.php,
+                mysqlVersion: components.mysql,
+                mariadbVersion: components.mariadb,
+                emailsInQueue: utilization.emailsInQueue,
+                operatingSystem: operatingSystem.map {
+                    ServerInfo.OperatingSystem(
+                        label: $0.label,
+                        distribution: $0.distribution,
+                        version: $0.version,
+                        architecture: $0.architecture,
+                        endOfLife: $0.endOfLife,
+                        updates: $0.updates.map {
+                            ServerInfo.OperatingSystem.UpdateStatus(
+                                updateCount: $0.updateCount,
+                                securityUpdateCount: $0.securityUpdateCount,
+                                rebootRequired: $0.rebootRequired
+                            )
+                        }
+                    )
+                },
+                ports: ports?.map {
+                    ServerInfo.ServicePort(service: $0.service, status: $0.status, port: $0.port, proto: $0.proto)
+                },
+                load: ServerInfo.Load(
+                    minute1: load.minute1,
+                    minute5: load.minute5,
+                    minute15: load.minute15,
+                    percent: load.percent,
+                    cpuCount: load.cpuCount,
+                    level: load.level
+                ),
+                memory: ServerInfo.Memory(
+                    free: memory.free,
+                    used: memory.used,
+                    total: memory.total,
+                    percent: memory.percent
+                ),
+                swap: ServerInfo.Memory(
+                    free: swapMemory.free,
+                    used: swapMemory.used,
+                    total: swapMemory.total,
+                    percent: swapMemory.percent
+                ),
+                diskSpace: ServerInfo.DiskSpace(
+                    free: disk.free,
+                    used: disk.used,
+                    total: disk.total,
+                    percent: disk.percent
+                ),
+                panelVersion: meta.panelVersion,
+                panelBuild: String(meta.panelBuild),
+                apiVersion: meta.apiVersion,
+                additionalPHPInterpreters: additionalPhpInterpreters?.map {
+                    ServerInfo.PHPInterpreter(
+                        version: $0.version,
+                        fullVersion: $0.versionFull,
+                        path: $0.path,
+                        configFile: $0.configFile,
+                        extensions: [],
+                        memoryLimit: nil,
+                        maxExecutionTime: nil
+                    )
+                }
+            )
+        }
+    }
+}

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

@@ -9,42 +9,26 @@ import SwiftUI
 
 struct MainView: View {
     
+    private static let serverOrderKeyStatic = "serverOrder"
+    private static let storedServersKeyStatic = "storedServers"
+
     @State var showAddServerSheet: Bool = false
     @State private var serverBeingEdited: Server?
     @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()
     @State private var pingTimer: Timer?
-    private let serverOrderKey = "serverOrder"
+    private let serverOrderKey = MainView.serverOrderKeyStatic
+    private let storedServersKey = MainView.storedServersKeyStatic
 
-    @State private var servers: [Server] = {
-        if let data = UserDefaults.standard.data(forKey: "storedServers"),
-           let saved = try? JSONDecoder().decode([Server].self, from: data) {
-
-            if let idStrings = UserDefaults.standard.stringArray(forKey: "serverOrder") {
-                let idMap = idStrings.compactMap(UUID.init)
-                return saved.sorted { a, b in
-                    guard
-                        let i1 = idMap.firstIndex(of: a.id),
-                        let i2 = idMap.firstIndex(of: b.id)
-                    else { return false }
-                    return i1 < i2
-                }
-            }
-
-            return saved
-        }
-        return []
-    }()
+    @State private var servers: [Server] = MainView.loadStoredServers()
 
 //    @State private var selectedServer: Server?
     @State private var selectedServerID: UUID?
 
     var body: some View {
-            
+        var mainContent: some View {
             NavigationSplitView {
                 List(selection: $selectedServerID) {
                 ForEach(servers) { server in
@@ -91,6 +75,8 @@ struct MainView: View {
                 ContentUnavailableView("No Server Selected", systemImage: "server.rack")
             }
             }
+        }
+        return mainContent
         .sheet(isPresented: $showAddServerSheet) {
             ServerFormView(
                 mode: .add,
@@ -113,17 +99,30 @@ struct MainView: View {
         }
         .onReceive(refreshTimer) { _ in
             for server in servers {
-                print("fetching server: \(server.hostname)")
                 fetchServerInfo(for: server.id)
             }
         }
         .onAppear {
+            let initialID: UUID?
             if let storedID = UserDefaults.standard.string(forKey: "selectedServerID"),
                let uuid = UUID(uuidString: storedID),
                servers.contains(where: { $0.id == uuid }) {
-                selectedServerID = uuid
-            } else if selectedServerID == nil, let first = servers.first {
-                selectedServerID = first.id
+                print("✅ [MainView] Restored selected server \(uuid)")
+                initialID = uuid
+            } else if let first = servers.first {
+                print("✅ [MainView] Selecting first server \(first.hostname)")
+                initialID = first.id
+            } else {
+                print("ℹ️ [MainView] No stored selection")
+                initialID = nil
+            }
+
+            selectedServerID = initialID
+
+            if let initialID {
+                Task {
+                    await prefetchOtherServers(activeID: initialID)
+                }
             }
             pingAllServers()
             pingTimer = Timer.scheduledTimer(withTimeInterval: 10.0, repeats: true) { _ in
@@ -131,12 +130,20 @@ struct MainView: View {
             }
         }
         .frame(minWidth: 800, minHeight: 450)
-
     }
     
     private func fetchServerInfo(for id: UUID) {
-        guard let server = servers.first(where: { $0.id == id }),
-              let api = ServerAPI(server: server) else {
+        guard let server = servers.first(where: { $0.id == id }) else {
+            print("❌ [MainView] fetchServerInfo: server not found for id \(id)")
+            return
+        }
+        guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !apiKey.isEmpty else {
+            print("❌ [MainView] fetchServerInfo: missing API key for \(server.hostname)")
+            return
+        }
+        guard let baseURL = URL(string: "https://\(server.hostname)") else {
+            print("❌ [MainView] Invalid base URL for \(server.hostname)")
             return
         }
 
@@ -145,18 +152,54 @@ struct MainView: View {
         Task {
             defer { isFetchingInfo = false }
             do {
-                let info = try await api.fetchServerInfo()
+                let api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
+                let info = try await api.fetchServerSummary(apiKey: apiKey)
+                await MainActor.run {
                     if let index = servers.firstIndex(where: { $0.id == id }) {
                         var updated = servers[index]
-                    updated.info = ServerInfo(from: info)
+                        updated.info = info
                         servers[index] = updated
                     }
+                }
             } catch {
                 print("❌ Failed to fetch server data: \(error)")
             }
         }
     }
 
+    private func prefetchOtherServers(activeID: UUID) async {
+        let others = servers.filter { $0.id != activeID }
+        await withTaskGroup(of: Void.self) { group in
+            for server in others {
+                group.addTask {
+                    await fetchServerInfoAsync(for: server.id)
+                }
+            }
+        }
+    }
+
+    private func fetchServerInfoAsync(for id: UUID) async {
+        guard let server = servers.first(where: { $0.id == id }) else { return }
+        guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !apiKey.isEmpty,
+              let baseURL = URL(string: "https://\(server.hostname)")
+        else { return }
+
+        do {
+            let api = try await APIFactory.detectAndCreateAPI(baseURL: baseURL, apiKey: apiKey)
+            let info = try await api.fetchServerSummary(apiKey: apiKey)
+            await MainActor.run {
+                if let index = servers.firstIndex(where: { $0.id == id }) {
+                    var updated = servers[index]
+                    updated.info = info
+                    servers[index] = updated
+                }
+            }
+        } catch {
+            print("❌ Prefetch failed for \(server.hostname): \(error)")
+        }
+    }
+    
     private func moveServer(from source: IndexSet, to destination: Int) {
         servers.move(fromOffsets: source, toOffset: destination)
         saveServerOrder()
@@ -165,65 +208,57 @@ struct MainView: View {
     private func saveServerOrder() {
         let ids = servers.map { $0.id.uuidString }
         UserDefaults.standard.set(ids, forKey: serverOrderKey)
+        print("💾 [MainView] Saved server order with \(ids.count) entries")
     }
     
     private struct PingResponse: Codable {
         let response: String
     }
         
-//    func pingServer(_ server: Server) async -> Bool {
-//        let hostname = server.hostname
-//        guard let url = URL(string: "https://\(hostname)/api/v2/ping") else {
-//            return false
-//        }
-//
-//        var request = URLRequest(url: url)
-//        request.httpMethod = "GET"
-//        request.timeoutInterval = 5
-//        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-//
-//        let apiKey = KeychainHelper.loadApiKey(for: hostname)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-//        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
-//
-//        do {
-//            let (data, response) = try await URLSession.shared.data(for: request)
-//            if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
-//                do {
-//                    let decoded = try JSONDecoder().decode(PingResponse.self, from: data)
-//                    if decoded.response == "pong" {
-//                        return true
-//                    } else {
-//                        print("❌ Unexpected response: \(decoded.response)")
-//                        return false
-//                    }
-//                } catch {
-//                    print("❌ Failed to decode JSON: \(error)")
-//                    return false
-//                }
-//            } else {
-//                return false
-//            }
-//        } catch {
-//            print("[Ping] \(server.hostname): \(error.localizedDescription)")
-//            return false
-//        }
-//    }
-    
     func pingAllServers() {
         for (index, server) in servers.enumerated() {
             Task {
                 let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-
-                let api = ServerAPI(hostname: server.hostname, apiKey: apiKey)
-                let pingable = await api.ping()
-
+                let pingable = await PingService.ping(hostname: server.hostname, apiKey: apiKey)
+                await MainActor.run {
                     servers[index].pingable = pingable
                 }
+                if !pingable {
+                    print("📶 [MainView] Ping \(server.hostname): offline")
+                }
             }
         }
     }
 
+    private static func loadStoredServers() -> [Server] {
+        let defaults = UserDefaults.standard
+        guard let data = defaults.data(forKey: storedServersKeyStatic) else {
+            print("ℹ️ [MainView] No storedServers data found")
+            return []
+        }
+        do {
+            let saved = try JSONDecoder().decode([Server].self, from: data)
+            print("📦 [MainView] Loaded \(saved.count) servers from UserDefaults")
+            if let order = defaults.stringArray(forKey: serverOrderKeyStatic) {
+                let idMap = order.compactMap(UUID.init)
+                let sorted = saved.sorted { a, b in
+                    guard
+                        let i1 = idMap.firstIndex(of: a.id),
+                        let i2 = idMap.firstIndex(of: b.id)
+                    else { return false }
+                    return i1 < i2
+                }
+                return sorted
+            }
+            return saved
+        } catch {
+            print("❌ [MainView] Failed to decode stored servers: \(error)")
+            return []
+        }
+    }
+}
 
 #Preview {
     MainView()
+        .environmentObject(SparkleUpdater())
 }

Sources/Views/PreferencesView.swift

@@ -0,0 +1,298 @@
+import SwiftUI
+
+struct PreferencesView: View {
+    private enum Tab: CaseIterable {
+        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"
+            }
+        }
+
+        var icon: String {
+            switch self {
+            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
+
+    @AppStorage("pingInterval") private var storedPingInterval: Int = 10
+    @AppStorage("refreshInterval") private var storedRefreshInterval: Int = 60
+    @AppStorage("showIntervalIndicator") private var showIntervalIndicator: Bool = true
+
+    @State private var pingIntervalSlider: Double = 10
+    @State private var refreshIntervalSlider: Double = 60
+    @State private var selection: Tab = .monitor
+    @State private var hoveredTab: Tab?
+
+    private let minimumInterval: Double = 10
+    private let maximumPingInterval: Double = 60
+    private let maximumRefreshInterval: Double = 600
+
+    var body: some View {
+        HStack(spacing: 0) {
+            sidebar
+            Divider()
+            ScrollView {
+                detailContent(for: selection)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding()
+            }
+            .frame(minWidth: 360, maxWidth: .infinity, maxHeight: .infinity)
+        }
+        .frame(minWidth: 560, minHeight: 360)
+        .onAppear {
+            pingIntervalSlider = Double(storedPingInterval)
+            refreshIntervalSlider = Double(storedRefreshInterval)
+        }
+        .onChange(of: pingIntervalSlider) { _, newValue in
+            storedPingInterval = Int(newValue)
+        }
+        .onChange(of: refreshIntervalSlider) { _, newValue in
+            storedRefreshInterval = Int(newValue)
+        }
+    }
+
+    private var sidebar: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Preferences")
+                .font(.headline)
+                .padding(.bottom, 8)
+
+            ForEach(Tab.allCases, id: \.self) { tab in
+                Button {
+                    selection = tab
+                } label: {
+                    HStack(spacing: 10) {
+                        Image(systemName: tab.icon)
+                            .frame(width: 20)
+                        Text(tab.title)
+                        Spacer()
+                    }
+                    .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())
+                .foregroundColor(selection == tab ? .white : .primary)
+                .onHover { isHovering in
+                    hoveredTab = isHovering ? tab : (hoveredTab == tab ? nil : hoveredTab)
+                }
+            }
+
+            Spacer()
+        }
+        .padding()
+        .frame(width: 180, alignment: .top)
+    }
+
+    @ViewBuilder
+    private func detailContent(for tab: Tab) -> some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text(tab.title)
+                .font(.title2)
+                .padding(.bottom, 12)
+
+            switch tab {
+            case .monitor:
+                MonitorPreferencesView(
+                    pingIntervalSlider: $pingIntervalSlider,
+                    refreshIntervalSlider: $refreshIntervalSlider,
+                    showIntervalIndicator: $showIntervalIndicator,
+                    minimumInterval: minimumInterval,
+                    maximumPingInterval: maximumPingInterval,
+                    maximumRefreshInterval: maximumRefreshInterval,
+                    pingChanged: handlePingSliderEditing(_:),
+                    refreshChanged: handleRefreshSliderEditing(_:)
+                )
+            case .notifications:
+                NotificationsPreferencesView()
+            case .alerts:
+                AlertsPreferencesView()
+            case .updates:
+                UpdatesPreferencesView()
+                    .environmentObject(sparkleUpdater)
+            }
+        }
+    }
+
+    private func handlePingSliderEditing(_ editing: Bool) {
+        if !editing {
+            storedPingInterval = Int(pingIntervalSlider)
+        }
+    }
+
+    private func handleRefreshSliderEditing(_ editing: Bool) {
+        if !editing {
+            storedRefreshInterval = Int(refreshIntervalSlider)
+        }
+    }
+    private func backgroundColor(for tab: Tab) -> Color {
+        if selection == tab {
+            return Color.accentColor
+        }
+        if hoveredTab == tab {
+            return Color.accentColor.opacity(0.2)
+        }
+        return Color.accentColor.opacity(0.08)
+    }
+}
+
+private struct MonitorPreferencesView: View {
+    @Binding var pingIntervalSlider: Double
+    @Binding var refreshIntervalSlider: Double
+    @Binding var showIntervalIndicator: Bool
+
+    let minimumInterval: Double
+    let maximumPingInterval: Double
+    let maximumRefreshInterval: Double
+    let pingChanged: (Bool) -> Void
+    let refreshChanged: (Bool) -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 24) {
+            intervalSection(
+                title: "Ping interval",
+                value: $pingIntervalSlider,
+                range: minimumInterval...maximumPingInterval,
+                onEditingChanged: pingChanged
+            )
+
+            intervalSection(
+                title: "Refresh interval",
+                value: $refreshIntervalSlider,
+                range: minimumInterval...maximumRefreshInterval,
+                onEditingChanged: refreshChanged
+            )
+
+            Divider()
+
+            Toggle("Show interval indicator", isOn: $showIntervalIndicator)
+                .toggleStyle(.switch)
+
+            Spacer()
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+
+    private func intervalSection(
+        title: String,
+        value: Binding<Double>,
+        range: ClosedRange<Double>,
+        onEditingChanged: @escaping (Bool) -> Void
+    ) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Text(title)
+                    .font(.headline)
+                Spacer()
+                Text("\(Int(value.wrappedValue)) seconds")
+                    .font(.subheadline)
+                    .foregroundColor(.secondary)
+            }
+
+            Slider(
+                value: value,
+                in: range,
+                step: 5
+            ) {
+                Text(title)
+            } minimumValueLabel: {
+                Text("\(Int(range.lowerBound))s")
+                    .font(.caption)
+                    .foregroundColor(.secondary)
+            } maximumValueLabel: {
+                Text("\(Int(range.upperBound))s")
+                    .font(.caption)
+                    .foregroundColor(.secondary)
+            } onEditingChanged: { editing in
+                onEditingChanged(editing)
+            }
+        }
+    }
+}
+
+private struct UpdatesPreferencesView: View {
+    @EnvironmentObject var sparkleUpdater: SparkleUpdater
+
+    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 {
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Notifications")
+                .font(.headline)
+                .padding(.bottom)
+
+            Text("Configure notification behavior here.")
+                .foregroundColor(.secondary)
+
+            Spacer()
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding()
+    }
+}
+
+private struct AlertsPreferencesView: View {
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Alerts")
+                .font(.headline)
+                .padding(.bottom)
+
+            Text("Configure alert thresholds and behavior.")
+                .foregroundColor(.secondary)
+
+            Spacer()
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding()
+    }
+}
+
+#Preview {
+    PreferencesView()
+}

Sources/Views/Rows/TableRowView.swift

@@ -17,6 +17,7 @@ struct TableRowView<Label: View, Value: View>: View {
             HStack(alignment: .top) {
                 label()
                     .frame(width: 180, alignment: .leading)
+                    .unredacted()
                 
                 value()
                     .frame(maxWidth: .infinity, alignment: .leading)

Sources/Views/ServerDetailView.swift

@@ -0,0 +1,98 @@
+//
+//  ServerDetailView.swift
+//  iKeyMon
+//
+//  Created by tracer on 30.03.25.
+//
+
+import SwiftUI
+
+struct ServerDetailView: View {
+    @Binding var server: Server
+    var isFetching: Bool
+    @AppStorage("showIntervalIndicator") private var showIntervalIndicator: Bool = true
+    
+    private var showPlaceholder: Bool {
+        server.info == nil
+    }
+    
+    @State private var progress: Double = 0
+    let timer = Timer.publish(every: 1.0 / 60.0, on: .main, in: .common).autoconnect()
+    
+    var body: some View {
+        VStack(spacing: 0) {
+            if showIntervalIndicator {
+                ProgressView(value: progress)
+                    .progressViewStyle(LinearProgressViewStyle())
+                    .padding(.horizontal)
+                    .frame(height: 2)
+            }
+            
+            ZStack(alignment: .topTrailing) {
+                VStack(spacing: 0) {
+                    Spacer().frame(height: 6)
+                    TabView {
+                        GeneralView(server: resolvedBinding)
+                            .tabItem {
+                                Text("General").unredacted()
+                            }
+                        ResourcesView(server: resolvedBinding)
+                            .tabItem {
+                                Text("Resources").unredacted()
+                            }
+                        ServicesView(server: resolvedBinding)
+                            .tabItem {
+                                Text("Services").unredacted()
+                            }
+                    }
+                    .redacted(reason: showPlaceholder ? .placeholder : [])
+                    .shimmering(active: showPlaceholder)
+                }
+                
+                if showPlaceholder || isFetching {
+                    LoadingBadge()
+                        .padding()
+                }
+            }
+            .padding(0)
+        }
+        .onReceive(timer) { _ in
+            guard showIntervalIndicator else { return }
+            withAnimation(.linear(duration: 1.0 / 60.0)) {
+                progress += 1.0 / (60.0 * 60.0)
+                if progress >= 1 { progress = 0 }
+            }
+        }
+    }
+    
+    private var resolvedBinding: Binding<Server> {
+        if showPlaceholder {
+            return .constant(placeholderServer())
+        }
+        return $server
+    }
+    
+    private func placeholderServer() -> Server {
+        Server(id: server.id, hostname: server.hostname, info: .placeholder, pingable: server.pingable)
+    }
+}
+
+#Preview {
+    ServerDetailView(
+        server: .constant(Server(id: UUID(), hostname: "preview.example.com", info: ServerInfo.placeholder)),
+        isFetching: false
+    )
+}
+
+private struct LoadingBadge: View {
+    var body: some View {
+        HStack(spacing: 6) {
+            ProgressView()
+                .scaleEffect(0.5)
+            Text("Fetching latest data…")
+                .font(.caption)
+        }
+        .padding(8)
+        .background(.ultraThinMaterial, in: Capsule())
+    }
+}

Sources/Views/ServerFormView.swift

@@ -102,8 +102,10 @@ struct ServerFormView: View {
         let host = hostname.trimmingCharacters(in: .whitespacesAndNewlines)
         let key = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
 
-        let pinger = ServerAPI(hostname: host, apiKey: key)
-        connectionOK = await pinger.ping()
+        let reachable = await PingService.ping(hostname: host, apiKey: key)
+        await MainActor.run {
+            connectionOK = reachable
+        }
 //
 //        guard let url = URL(string: "https://\(host)/api/v2/ping") else {
 //            print("❌ Invalid URL")
@@ -183,7 +185,7 @@ struct ServerFormView: View {
             print("adding server")
             let newServer = Server(hostname: trimmedHost)
             servers.append(newServer)
-            KeychainHelper.save(apiKey: trimmedKey, for: trimmedHost)
+            KeychainHelper.saveApiKey(trimmedKey, for: trimmedHost)
             saveServers()
         case .edit(let oldServer):
             if let index = servers.firstIndex(where: { $0.id == oldServer.id }) {
@@ -192,7 +194,7 @@ struct ServerFormView: View {
                 if oldHostname != trimmedHost {
                     KeychainHelper.deleteApiKey(for: oldHostname)
                 }
-                KeychainHelper.save(apiKey: trimmedKey, for: trimmedHost)
+                KeychainHelper.saveApiKey(trimmedKey, for: trimmedHost)
             }
         }
     }
@@ -212,7 +214,7 @@ struct ServerFormView: View {
             if oldHostname != hostname {
                 KeychainHelper.deleteApiKey(for: oldHostname)
             }
-            KeychainHelper.save(apiKey: apiKey, for: hostname)
+            KeychainHelper.saveApiKey(apiKey, for: hostname)
             saveServers()
         }
     }

Sources/Views/Tabs/GeneralView.swift

@@ -0,0 +1,140 @@
+//
+//  GeneralTab.swift
+//  iKeyMon
+//
+//  Created by tracer on 30.03.25.
+//
+
+import SwiftUI
+
+struct GeneralView: View {
+    @Binding var server: Server
+    
+    var body: some View {
+        GeometryReader { geometry in
+            ScrollView {
+                VStack(alignment: .leading, spacing: 6) {
+                    TableRowView {
+                        Text("Hostname")
+                    } value: {
+                        InfoCell(value: [server.hostname])
+                    }
+                    
+                    TableRowView {
+                        Text("IP addresses")
+                    } value: {
+                        InfoCell(value: server.info?.ipAddresses ?? [], monospaced: true)
+                    }
+                    
+                    TableRowView {
+                        Text("Server time")
+                    } value: {
+                        InfoCell(value: [server.info?.formattedServerTime ?? ""], monospaced: true)
+                    }
+
+                    TableRowView {
+                        Text("Uptime")
+                    } value: {
+                        InfoCell(value: [server.info?.uptime ?? ""])
+                    }
+
+                    TableRowView {
+                        Text("KeyHelp version")
+                    } value: {
+                        InfoCell(value: [server.info?.formattedVersion ?? ""], monospaced: true)
+                    }
+
+                    TableRowView {
+                        Text("Operating system")
+                    } value: {
+                        InfoCell(
+                            value: {
+                                guard let os = server.info?.operatingSystem else { return [] }
+                                var rows: [String] = []
+
+                                let distro = [os.distribution, os.version]
+                                    .filter { !$0.isEmpty }
+                                    .joined(separator: " ")
+                                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                                var description = os.label.trimmingCharacters(in: .whitespacesAndNewlines)
+                                if description.isEmpty {
+                                    description = distro
+                                } else if !distro.isEmpty && description.range(of: distro, options: [.caseInsensitive]) == nil {
+                                    description += " • \(distro)"
+                                }
+                                if !os.architecture.isEmpty &&
+                                    description.range(of: os.architecture, options: [.caseInsensitive]) == nil {
+                                    description += " (\(os.architecture))"
+                                }
+                                if !description.isEmpty {
+                                    rows.append(description)
+                                }
+
+                                if let updates = os.updates {
+                                    var updateDescription = "Updates: \(updates.updateCount)"
+                                    if updates.securityUpdateCount > 0 {
+                                        updateDescription += " • \(updates.securityUpdateCount) security"
+                                    }
+                                    rows.append(updateDescription)
+                                    if updates.rebootRequired {
+                                        rows.append("Reboot required")
+                                    }
+                                }
+
+                                if os.endOfLife {
+                                    rows.append("End-of-life release")
+                                }
+
+                                return rows
+                            }(),
+                            monospaced: true
+                        )
+                    }
+
+                    TableRowView {
+                        Text("Sytem PHP version")
+                    } value: {
+                        InfoCell(value: [server.info?.phpVersion ?? ""], monospaced: true)
+                    }
+
+                    TableRowView(showDivider: false) {
+                        Text("Additional PHP interpreters")
+                    } value: {
+                        InfoCell(
+                            value: {
+                                let interpreters = server.info?.additionalPHPInterpreters ?? []
+                                if interpreters.isEmpty {
+                                    return ["None"]
+                                }
+                                let versions = interpreters
+                                    .map { $0.fullVersion }
+                                    .filter { !$0.isEmpty }
+                                if versions.isEmpty {
+                                    return ["None"]
+                                }
+                                return [versions.joined(separator: " • ")]
+                            }(),
+                            monospaced: true
+                        )
+                    }
+                }
+                .padding()
+                .frame(minHeight: geometry.size.height, alignment: .top)
+            }
+            .padding()
+            .scrollDisabled(true)
+        }
+    }
+}
+
+#Preview {
+    struct PreviewWrapper: View {
+        @State var previewServer = Server(hostname: "example.com", info: .placeholder)
+
+        var body: some View {
+            GeneralView(server: $previewServer)
+        }
+    }
+
+    return PreviewWrapper()
+}

Sources/iKeyMonApp.swift

@@ -0,0 +1,41 @@
+//
+//  iKeyMonApp.swift
+//  iKeyMon
+//
+//  Created by tracer on 30.03.25.
+//
+
+import SwiftUI
+#if os(macOS)
+import AppKit
+#endif
+
+@main
+struct iKeyMonApp: App {
+    @StateObject private var sparkleUpdater = SparkleUpdater()
+
+    init() {
+        #if os(macOS)
+        if let customIcon = NSImage(named: "AppIcon") {
+            NSApplication.shared.applicationIconImage = customIcon
+        }
+        #endif
+    }
+
+    var body: some Scene {
+        WindowGroup {
+            MainView()
+                .environmentObject(sparkleUpdater)
+                .onDisappear {
+                    NSApp.terminate(nil)
+                }
+        }
+        .windowResizability(.contentMinSize)
+
+        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.0.69</title>
+            <pubDate>Sat, 03 Jan 2026 14:00:40 +0100</pubDate>
+            <sparkle:version>150</sparkle:version>
+            <sparkle:shortVersionString>26.0.69</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.0.69/iKeyMon-26.0.69.zip" length="2993457" type="application/octet-stream" sparkle:edSignature="cIqWamcPRsxA7zPaGcUuUOqLYs5KTcoAgXQkhblCF+Wc2tEnGHFVysARtMH68jGq7ObfhDuI3oZJNg857rQ0Dg=="/>
+        </item>
+        <item>
+            <title>26.0.68</title>
+            <pubDate>Sat, 03 Jan 2026 13:52:33 +0100</pubDate>
+            <sparkle:version>148</sparkle:version>
+            <sparkle:shortVersionString>26.0.68</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.0.68/iKeyMon-26.0.68.zip" length="2993469" type="application/octet-stream" sparkle:edSignature="M5WBkO4BN8RwMJ0ZU3Ku4CyQllnbEzz9X6MYR4IVX5prO9oyMBGoceHA3C97wZA6+++9u7RnRsKrFvei2CsWBQ=="/>
+        </item>
+        <item>
+            <title>26.0.67</title>
+            <pubDate>Sat, 03 Jan 2026 13:36:29 +0100</pubDate>
+            <sparkle:version>146</sparkle:version>
+            <sparkle:shortVersionString>26.0.67</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>15.2</sparkle:minimumSystemVersion>
+            <enclosure url="https://git.24unix.net/tracer/iKeyMon/releases/download/v26.0.67/iKeyMon-26.0.67.zip" length="2993400" type="application/octet-stream" sparkle:edSignature="kr7vKMSM0002I/Fx2KVFGqNA6uMHb5Ll6Cr8NSG+8/Ct6KkC9dAwcd50xeUVPVJ7UT8lNBVPoBjZoFssgIEPAw=="/>
+        </item>
+    </channel>
+</rss>

hooks/pre-push

@@ -0,0 +1,84 @@
+#!/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/build/release.log}"
+
+if [[ -n "${SKIP_RELEASE:-}" ]]; then
+  echo "release: skipped (SKIP_RELEASE=1)"
+  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; skipping commit"
+else
+  run_logged git -C "$ROOT_DIR" commit -m "chore: release ${NEW_VERSION}" || {
+    echo "release: commit failed (log: $RELEASE_LOG)"
+    exit 1
+  }
+fi
+
+if SKIP_RELEASE=1 git -C "$ROOT_DIR" push --quiet "$REMOTE_NAME" "${release_local_ref:-refs/heads/master}:${release_remote_ref:-refs/heads/master}"; then
+  echo "release: success v${NEW_VERSION}"
+  exit 1
+else
+  echo "release: push failed (log: $RELEASE_LOG)"
+  exit 1
+fi

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

@@ -6,14 +6,48 @@
 	objectVersion = 77;
 	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 */
-		5203C24F2D997D2800576D4A /* iKeyMon */ = {
+		52A9B8BE2ECB68B5004DD4A2 /* Sources */ = {
 			isa = PBXFileSystemSynchronizedRootGroup;
-			path = iKeyMon;
+			path = Sources;
+			sourceTree = "<group>";
+		};
+		52A9B8F72ECB6B8A004DD4A2 /* Preview Content */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			path = "Preview Content";
 			sourceTree = "<group>";
 		};
 /* End PBXFileSystemSynchronizedRootGroup section */
@@ -23,6 +57,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				52A9BD112ED377F7004DD4A2 /* Sparkle in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -32,8 +67,18 @@
 		5203C2442D997D2800576D4A = {
 			isa = PBXGroup;
 			children = (
-				5203C24F2D997D2800576D4A /* iKeyMon */,
+				52A9C38F2ED4D753004DD4A2 /* iKeyMon-Info.plist */,
+				52A9B8BE2ECB68B5004DD4A2 /* Sources */,
+				52A9B7872EC8E7EE004DD4A2 /* Assets.xcassets */,
+				52A9B7882EC8E7EE004DD4A2 /* iKeyMon.entitlements */,
+				52A9B8F72ECB6B8A004DD4A2 /* Preview Content */,
 				5203C24E2D997D2800576D4A /* Products */,
+				52A9B8212EC8FA8A004DD4A2 /* CHANGELOG.md */,
+				52A9B8BA2ECA35FB004DD4A2 /* NOTES.md */,
+				52A9B9712ECF751C004DD4A2 /* signing.env.example */,
+				52A9BEC92ED3874F004DD4A2 /* README.md */,
+				52A9BD122ED37E08004DD4A2 /* Frameworks */,
+				5221016C2EE5E82700D04952 /* Sparkle */,
 			);
 			sourceTree = "<group>";
 		};
@@ -45,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 */
@@ -55,16 +115,19 @@
 				5203C2492D997D2800576D4A /* Sources */,
 				5203C24A2D997D2800576D4A /* Frameworks */,
 				5203C24B2D997D2800576D4A /* Resources */,
+				52A9BD152ED37BD8004DD4A2 /* CopyFiles */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 			);
 			fileSystemSynchronizedGroups = (
-				5203C24F2D997D2800576D4A /* iKeyMon */,
+				52A9B8BE2ECB68B5004DD4A2 /* Sources */,
+				52A9B8F72ECB6B8A004DD4A2 /* Preview Content */,
 			);
 			name = iKeyMon;
 			packageProductDependencies = (
+				52A9BD102ED377F7004DD4A2 /* Sparkle */,
 			);
 			productName = iKeyMon;
 			productReference = 5203C24D2D997D2800576D4A /* iKeyMon.app */;
@@ -94,6 +157,9 @@
 			);
 			mainGroup = 5203C2442D997D2800576D4A;
 			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				52A9BD0F2ED377F7004DD4A2 /* XCRemoteSwiftPackageReference "Sparkle" */,
+			);
 			preferredProjectObjectVersion = 77;
 			productRefGroup = 5203C24E2D997D2800576D4A /* Products */;
 			projectDirPath = "";
@@ -109,6 +175,11 @@
 			isa = PBXResourcesBuildPhase;
 			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 */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -248,21 +319,25 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
-				CODE_SIGN_ENTITLEMENTS = iKeyMon/iKeyMon.entitlements;
+				CODE_SIGN_ENTITLEMENTS = iKeyMon.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_ASSET_PATHS = "\"iKeyMon/Preview Content\"";
+				CURRENT_PROJECT_VERSION = 150;
+				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.0.69;
 				PRODUCT_BUNDLE_IDENTIFIER = net.24unix.iKeyMon;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -275,21 +350,25 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
-				CODE_SIGN_ENTITLEMENTS = iKeyMon/iKeyMon.entitlements;
+				CODE_SIGN_ENTITLEMENTS = iKeyMon.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_ASSET_PATHS = "\"iKeyMon/Preview Content\"";
+				CURRENT_PROJECT_VERSION = 150;
+				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.0.69;
 				PRODUCT_BUNDLE_IDENTIFIER = net.24unix.iKeyMon;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -319,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
+}

iKeyMon/Model/API/ServerResponse.swift

@@ -1,179 +0,0 @@
-//
-//  ServerResponse.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import Foundation
-import Foundation
-
-// MARK: - Root Response
-struct ServerResponse: Decodable {
-    let meta: Meta
-    let operatingSystem: OperatingSystem
-    let utilization: Utilization
-    let resources: Resources
-    let components: Components
-    let additionalPHPInterpreters: [PHPInterpreter]?
-    let ports: [ServicePort]?
-
-    enum CodingKeys: String, CodingKey {
-        case meta
-        case operatingSystem = "operating_system"
-        case utilization, resources, components
-        case additionalPHPInterpreters = "additional_php_interpreters"
-        case ports
-    }
-}
-
-// MARK: - Meta
-struct Meta: Decodable {
-    let hostname: String
-    let ipAddresses: [String]
-    let serverTime: String
-    let uptime: Uptime
-    let panelVersion: String
-    let panelBuild: String
-    let apiVersion: String
-    let apiDocs: String
-    let keyhelpPro: Bool
-
-    enum CodingKeys: String, CodingKey {
-        case hostname
-        case ipAddresses = "ip_addresses"
-        case serverTime = "server_time"
-        case uptime
-        case panelVersion = "panel_version"
-        case panelBuild = "panel_build"
-        case apiVersion = "api_version"
-        case apiDocs = "api_docs"
-        case keyhelpPro = "keyhelp_pro"
-    }
-}
-
-struct Uptime: Decodable {
-    let days, hours, minutes, seconds: Int
-}
-
-// MARK: - OperatingSystem
-struct OperatingSystem: Decodable {
-    let label, distribution, version, architecture: String
-    let endOfLife: Bool
-    let updates: Updates
-
-    enum CodingKeys: String, CodingKey {
-        case label, distribution, version, architecture
-        case endOfLife = "end_of_life"
-        case updates
-    }
-}
-
-struct Updates: Decodable {
-    let updateCount, securityUpdateCount: Int
-    let rebootRequired: Bool
-
-    enum CodingKeys: String, CodingKey {
-        case updateCount = "update_count"
-        case securityUpdateCount = "security_update_count"
-        case rebootRequired = "reboot_required"
-    }
-}
-
-// MARK: - Utilization
-struct Utilization: Decodable {
-    let processCount, emailsInQueue: Int
-    let load: Load
-    let diskSpace: DiskSpace
-    let inodes: Inodes
-    let memory, swap: Memory
-
-    enum CodingKeys: String, CodingKey {
-        case processCount = "process_count"
-        case emailsInQueue = "emails_in_queue"
-        case load
-        case diskSpace = "disk_space"
-        case inodes, memory, swap
-    }
-}
-
-struct Load: Decodable {
-    let minute1, minute5, minute15, percent: Double
-    let cpuCount: Int
-    let level: String
-
-    enum CodingKeys: String, CodingKey {
-        case minute1 = "minute_1"
-        case minute5 = "minute_5"
-        case minute15 = "minute_15"
-        case cpuCount = "cpu_count"
-        case percent, level
-    }
-}
-
-struct DiskSpace: Decodable {
-    let free, used, total: Int
-    let percent: Double
-}
-
-struct Inodes: Decodable {
-    let free, used, total: Int
-    let percent: Double
-}
-
-struct Memory: Decodable {
-    let free, used, total: Int
-    let percent: Double
-}
-
-// MARK: - Resources
-struct Resources: Decodable {
-    let adminAccounts, clientAccounts, domains, subdomains: Int
-    let emailAccounts, emailAddresses, emailForwardings, databases: Int
-    let ftpUsers, scheduledTasks: Int
-    let consumedDiskSpace, traffic: Int
-
-    enum CodingKeys: String, CodingKey {
-        case adminAccounts = "admin_accounts"
-        case clientAccounts = "client_accounts"
-        case domains, subdomains
-        case emailAccounts = "email_accounts"
-        case emailAddresses = "email_addresses"
-        case emailForwardings = "email_forwardings"
-        case databases
-        case ftpUsers = "ftp_users"
-        case scheduledTasks = "scheduled_tasks"
-        case consumedDiskSpace = "consumed_disk_space"
-        case traffic
-    }
-}
-
-// MARK: - Components
-struct Components: Decodable {
-    let kernel, apache, php, proftpd, dovecot, postfix: String
-    let mariadb, mysql: String?
-}
-
-struct PHPInterpreter: Decodable {
-    let version, versionFull: String
-
-    enum CodingKeys: String, CodingKey {
-        case version
-        case versionFull = "version_full"
-    }
-}
-
-struct ServicePort: Decodable, Identifiable {
-    let service: String
-    let port: Int
-    let proto: String
-    let status: String
-    var id: String { service }
-
-    enum CodingKeys: String, CodingKey {
-        case service
-        case port
-        case proto = "protocol"
-        case status
-    }
-}

iKeyMon/Model/Server.swift

@@ -1,39 +0,0 @@
-//
-//  Server.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import Foundation
-
-struct Server: Identifiable, Codable, Hashable, Equatable {
-    let id: UUID
-    var hostname: String
-
-    // runtime-only, skip for Codable / Hashable / Equatable
-    var info: ServerInfo? = nil
-    var pingable: Bool = false
-
-    init(id: UUID = UUID(), hostname: String, info: ServerInfo? = nil, pingable: Bool = false) {
-        self.id = id
-        self.hostname = hostname
-        self.info = info
-        self.pingable = pingable
-    }
-
-    // MARK: - Manual conformance
-
-    static func == (lhs: Server, rhs: Server) -> Bool {
-        lhs.id == rhs.id && lhs.hostname == rhs.hostname && lhs.info == rhs.info && lhs.pingable == rhs.pingable
-    }
-
-    func hash(into hasher: inout Hasher) {
-        hasher.combine(id)
-        hasher.combine(hostname)
-    }
-
-    enum CodingKeys: String, CodingKey {
-        case id, hostname
-    }
-}

iKeyMon/Model/ServerInfo.swift

@@ -1,124 +0,0 @@
-//
-//  ServerInfo.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import Foundation
-
-struct ServerInfo: Decodable, Equatable {
-    static func == (lhs: ServerInfo, rhs: ServerInfo) -> Bool {
-        lhs.hostname == rhs.hostname && lhs.serverTime == rhs.serverTime
-    }
-    
-    var hostname: String
-    var ipAddresses: [String]
-//    var processor: String
-    var cpuCores: Int
-//    var virtualization: String
-    var serverTime: String
-    var uptime: String
-//    var sshFingerprint: String
-    var processCount: Int
-    var apacheVersion: String
-    var phpVersion: String
-    var mysqlVersion: String?
-    var mariadbVersion: String?
-    var ports: [ServicePort]?
-    var load: Load
-    var memory: Memory
-    var swap: Memory
-    var diskSpace: DiskSpace
-    var panelVersion: String
-    var panelBuild: String
-    var apiVersion: String
-    var additionalPHPInterpreters: [PHPInterpreter]?
-
-    
-}
-
-extension ServerInfo {
-    static let placeholder = ServerInfo(
-        hostname: "keyhelp.lab.24unix.net",
-        ipAddresses: ["192.168.99.44", "2a03:..."],
-//        processor: "Common processor (arm64)",
-        cpuCores: 8,
-//        virtualization: "QEMU",
-        serverTime: "Sunday, March 30, 2025 at 08:01 PM (Europe/Berlin)",
-        uptime: "6 Days / 7 Hours / 16 Minutes",
-//        sshFingerprint: "Ed25519 / ECDSA / RSA",
-        processCount: 123,
-        apacheVersion: "2.4",
-        phpVersion: "8.4",
-        ports: [],
-        load: Load(
-            minute1: 0.42,
-            minute5: 0.31,
-            minute15: 0.29,
-            percent: 10.5,
-            cpuCount: 4,
-            level: "low"
-        ),
-        memory: Memory(free: 1234, used: 4567, total: 123456, percent: 23.45),
-        swap: Memory(free: 1234, used: 4567, total: 123456, percent: 23.45),
-        diskSpace:  DiskSpace(free: 1234, used: 4567, total: 123456, percent: 23.45),
-        panelVersion: "25.0",
-        panelBuild: "3394",
-        apiVersion: "2.0"
-    )
-    
-    var cpuLoadDetail: String {
-        "1min: \(load.minute1), 5min: \(load.minute5), 15min: \(load.minute15) (\(load.level))"
-    }
-    
-    var formattedServerTime: String {
-        let isoFormatter = ISO8601DateFormatter()
-        let formatter = DateFormatter()
-        formatter.locale = Locale(identifier: "de_DE")
-        formatter.dateStyle = .medium
-        formatter.timeStyle = .short
-
-        if let date = isoFormatter.date(from: serverTime) {
-            return formatter.string(from: date)
-        } else {
-            return serverTime // fallback to raw string if parsing fails
-        }
-    }
-    
-    var formattedVersion: String {
-        "\(panelVersion) (Build \(panelBuild))"
-    }
-}
-
-extension ServerInfo {
-    init(from response: ServerResponse) {
-        self.hostname = response.meta.hostname
-        self.ipAddresses = response.meta.ipAddresses
-        self.serverTime = response.meta.serverTime
-
-        let u = response.meta.uptime
-        self.uptime = "\(u.days) Days / \(u.hours) Hours / \(u.minutes) Minutes"
-
-        self.cpuCores = response.utilization.load.cpuCount
-        self.processCount = response.utilization.processCount
-
-        self.apacheVersion = response.components.apache
-        self.phpVersion = response.components.php
-
-        self.mysqlVersion = response.components.mysql ?? ""
-        self.mariadbVersion = response.components.mariadb ?? ""
-        
-        self.ports = response.ports
-        
-        self.load = response.utilization.load
-        self.memory = response.utilization.memory
-        self.swap = response.utilization.swap
-        self.diskSpace = response.utilization.diskSpace
-        
-        self.panelVersion = response.meta.panelVersion
-        self.panelBuild = response.meta.panelBuild
-        self.apiVersion = response.meta.apiVersion
-        self.additionalPHPInterpreters = response.additionalPHPInterpreters
-    }
-}

iKeyMon/ServerAPI.swift

@@ -1,67 +0,0 @@
-//
-//  ServerAPI.swift
-//  iKeyMon
-//
-//  Created by tracer on 06.04.25.
-//
-import Foundation
-
-final class ServerAPI {
-    private let hostname: String
-    private let apiKey: String
-
-    init(hostname: String, apiKey: String) {
-        self.hostname = hostname
-        self.apiKey = apiKey
-    }
-
-    init?(server: Server) {
-        guard let apiKey = KeychainHelper.loadApiKey(for: server.hostname)?.trimmingCharacters(in: .whitespacesAndNewlines) else {
-            return nil
-        }
-        self.hostname = server.hostname
-        self.apiKey = apiKey
-    }
-
-    @discardableResult
-    func ping() async -> Bool {
-        guard let url = URL(string: "https://\(hostname)/api/v2/ping") else {
-            return false
-        }
-
-        var request = URLRequest(url: url)
-        request.httpMethod = "GET"
-        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
-
-        do {
-            let (data, _ /*response */) = try await URLSession.shared.data(for: request)
-//            if let httpResponse = response as? HTTPURLResponse {
-//                print("data: \(String(data: data, encoding: .utf8))")
-//            }
-
-            if let result = try? JSONDecoder().decode([String: String].self, from: data), result["response"] == "pong" {
-                return true
-            }
-        } catch {
-            print("❌ Ping error: \(error)")
-        }
-
-        return false
-    }
-    
-    func fetchServerInfo() async throws -> ServerResponse {
-        guard let url = URL(string: "https://\(hostname)/api/v2/server") else {
-            throw URLError(.badURL)
-        }
-
-        var request = URLRequest(url: url)
-        request.httpMethod = "GET"
-        request.setValue(apiKey, forHTTPHeaderField: "X-API-KEY")
-        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-
-        let (data, _) = try await URLSession.shared.data(for: request)
-        let decoded = try JSONDecoder().decode(ServerResponse.self, from: data)
-                
-        return decoded
-    }
-}

iKeyMon/Views/ServerDetailView.swift

@@ -1,89 +0,0 @@
-//
-//  ServerDetailView.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import SwiftUI
-
-struct ServerDetailView: View {
-    @Binding var server: Server
-    var isFetching: Bool
-    
-    @State private var progress: Double = 0
-    let timer = Timer.publish(every: 1.0 / 60.0, on: .main, in: .common).autoconnect()
-    
-    var body: some View {
-        VStack(spacing: 0) {
-            ProgressView(value: progress)
-                .progressViewStyle(LinearProgressViewStyle())
-                .padding(.horizontal)
-                .frame(height: 2)
-            
-            if server.info == nil {
-                ProgressView("Fetching server info...")
-                    .frame(maxWidth: .infinity, maxHeight: .infinity)
-            } else {
-                ZStack(alignment: .topTrailing) {
-                    VStack(spacing: 0) {
-                        Spacer().frame(height: 6)
-                        TabView {
-                            GeneralView(server: $server)
-                                .tabItem {
-                                    Text("General")
-                                }
-                            ResourcesView(server: $server)
-                                .tabItem {
-                                    Text("Resources")
-                                }
-                            ServicesView(server: $server)
-                                .tabItem {
-                                    Text("Services")
-                                }
-                        }
-                    }
-                    
-                    if isFetching {
-                        ProgressView()
-                            .scaleEffect(0.5)
-                            .padding()
-                    }
-                }
-                .padding(0)
-            }
-        }
-        .onReceive(timer) { _ in
-            withAnimation(.linear(duration: 1.0 / 60.0)) {
-                progress += 1.0 / (60.0 * 60.0)
-                if progress >= 1 { progress = 0 }
-            }
-        }
-    }
-}
-
-#Preview {
-    ServerDetailView(
-        server: .constant(Server(id: UUID(), hostname: "preview.example.com", info: ServerInfo(
-            hostname: "preview.example.com",
-            ipAddresses: ["192.168.1.1", "fe80::1"],
-            cpuCores: 4,
-            serverTime: "2025-04-04T18:00:00+0200",
-            uptime: "3 Days / 12 Hours / 30 Minutes",
-            processCount: 123,
-            apacheVersion: "2.4.58",
-            phpVersion: "8.2.12",
-            mysqlVersion: "8.0.33",
-            mariadbVersion: nil,
-            ports: nil,
-            load: Load(minute1: 0.5, minute5: 0.3, minute15: 0.2, percent: 10.0, cpuCount: 4, level: "low"),
-            memory: Memory(free: 8_000_000_000, used: 4_000_000_000, total: 12_000_000_000, percent: 33.3),
-            swap: Memory(free: 4_000_000_000, used: 1_000_000_000, total: 5_000_000_000, percent: 20.0),
-            diskSpace: DiskSpace(free: 100_000_000_000, used: 50_000_000_000, total: 150_000_000_000, percent: 33.3),
-            panelVersion: "25.0",
-            panelBuild: "3394",
-            apiVersion: "2"
-        ))),
-        isFetching: false
-    )
-}

iKeyMon/Views/Tabs/GeneralView.swift

@@ -1,81 +0,0 @@
-//
-//  GeneralTab.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import SwiftUI
-
-struct GeneralView: View {
-    @Binding var server: Server
-    
-    var body: some View {
-        GeometryReader { geometry in
-            ScrollView {
-                VStack(alignment: .leading, spacing: 6) {
-                    TableRowView {
-                        Text("Hostname")
-                    } value: {
-                        InfoCell(value: [server.hostname])
-                    }
-                    
-                    TableRowView {
-                        Text("IP addresses")
-                    } value: {
-                        InfoCell(value: server.info?.ipAddresses ?? [], monospaced: true)
-                    }
-                    
-                    TableRowView {
-                        Text("Server time")
-                    } value: {
-                        InfoCell(value: [server.info?.formattedServerTime ?? ""], monospaced: true)
-                    }
-
-                    TableRowView {
-                        Text("Uptime")
-                    } value: {
-                        InfoCell(value: [server.info?.uptime ?? ""])
-                    }
-
-                    TableRowView {
-                        Text("KeyHelp version")
-                    } value: {
-                        InfoCell(value: [server.info?.formattedVersion ?? ""], monospaced: true)
-                    }
-
-                    TableRowView {
-                        Text("Sytem PHP version")
-                    } value: {
-                        InfoCell(value: [server.info?.phpVersion ?? ""], monospaced: true)
-                    }
-
-                    TableRowView(showDivider: false) {
-                        Text("Additional PHP interpreters")
-                    } value: {
-                        InfoCell(
-                            value: server.info?.additionalPHPInterpreters?.map { $0.versionFull } ?? [],
-                            monospaced: true
-                        )
-                    }
-                }
-                .padding()
-                .frame(minHeight: geometry.size.height, alignment: .top)
-            }
-            .padding()
-            .scrollDisabled(true)
-        }
-    }
-}
-
-#Preview {
-    struct PreviewWrapper: View {
-        @State var previewServer = Server(hostname: "example.com", info: .placeholder)
-
-        var body: some View {
-            GeneralView(server: $previewServer)
-        }
-    }
-
-    return PreviewWrapper()
-}

iKeyMon/iKeyMonApp.swift

@@ -1,21 +0,0 @@
-//
-//  iKeyMonApp.swift
-//  iKeyMon
-//
-//  Created by tracer on 30.03.25.
-//
-
-import SwiftUI
-
-@main
-struct iKeyMonApp: App {
-    var body: some Scene {
-        WindowGroup {
-            MainView()
-                .onDisappear {
-                    NSApp.terminate(nil)
-                }
-        }
-        .windowResizability(.contentMinSize)
-    }
-}

scripts/build_release.sh

@@ -0,0 +1,224 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BUILD_DIR="$ROOT_DIR/build"
+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
+
+: "${SPARKLE_APPCAST_OUTPUT:=$ROOT_DIR/Sparkle/appcast.xml}"
+export SPARKLE_APPCAST_OUTPUT
+
+"$ROOT_DIR/scripts/sync_version.sh"
+
+rm -rf "$BUILD_DIR" "$ARTIFACTS_DIR"
+mkdir -p "$ARTIFACTS_DIR"
+
+xcodebuild \
+  -project "$ROOT_DIR/$PROJECT" \
+  -scheme "$SCHEME" \
+  -configuration Release \
+  -derivedDataPath "$BUILD_DIR" \
+  CODE_SIGNING_ALLOWED=NO \
+  clean build
+
+APP_PATH="$BUILD_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 \
+    --force \
+    --options runtime \
+    --timestamp \
+    --entitlements "$ROOT_DIR/iKeyMon.entitlements" \
+    --sign "$CODESIGN_IDENTITY" \
+    "$APP_PATH"
+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/"
+ln -s /Applications "$STAGING_DIR/Applications"
+mkdir -p "$STAGING_DIR/.background"
+cp "$ROOT_DIR/Assets/dmg_background.png" "$STAGING_DIR/.background/background.png"
+
+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"
+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
+  notarize_artifact "$ARTIFACTS_DIR/$DMG_NAME" "$DMG_NAME"
+else
+  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"
+else
+  echo "ℹ️ Skipping Gitea release publishing (GITEA_* variables not fully set)."
+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,98 @@
+#!/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}"
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "❌ jq is required to parse Gitea responses." >&2
+  exit 1
+fi
+
+PRERELEASE_FLAG="${GITEA_PRERELEASE:-true}"
+
+create_payload="$(jq -n \
+  --arg tag "$RELEASE_TAG" \
+  --arg name "iKeyMon ${VERSION}" \
+  --arg target "$TARGET_COMMIT" \
+  --argjson prerelease "$PRERELEASE_FLAG" \
+  '{ tag_name: $tag, name: $name, target_commitish: $target, 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."

signing.env.example

@@ -0,0 +1,16 @@
+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.0.69"
+}