feat: add Pro feature gating for Safe Mode and XLSX export

- Gate Safe Mode (Touch ID), Safe Mode (Full), and Read-Only behind Pro
- Gate XLSX export behind Pro license
- Add standalone LicenseActivationSheet dialog, reusable from anywhere
- Centralize pricing URL in LicenseConstants
- Localize all LicenseError messages, add friendlyDescription
- Post licenseStatusDidChange notification on status transitions
- SyncCoordinator reacts to license changes automatically
- SyncStatusIndicator opens activation sheet when unlicensed
- SafeModeGuard gracefully downgrades Pro levels with logging
- Cache activation list in LicenseSettingsView

Author: datlechin

TablePro/Core/Services/Infrastructure/AppNotifications.swift

@@ -20,6 +20,10 @@ extension Notification.Name {
     static let connectionStatusDidChange = Notification.Name("connectionStatusDidChange")
     static let databaseDidConnect = Notification.Name("databaseDidConnect")
 
+    // MARK: - License
+
+    static let licenseStatusDidChange = Notification.Name("licenseStatusDidChange")
+
     // MARK: - SQL Favorites
 
     static let sqlFavoritesDidUpdate = Notification.Name("sqlFavoritesDidUpdate")

TablePro/Core/Services/Infrastructure/SafeModeGuard.swift

@@ -24,14 +24,22 @@ internal final class SafeModeGuard {
         window: NSWindow?,
         databaseType: DatabaseType? = nil
     ) async -> Permission {
+        let effectiveLevel: SafeModeLevel
+        if level.requiresPro && !LicenseManager.shared.isFeatureAvailable(.safeMode) {
+            logger.info("Safe mode \(level.rawValue) requires Pro license; downgrading to silent")
+            effectiveLevel = .silent
+        } else {
+            effectiveLevel = level
+        }
+
         let effectiveIsWrite: Bool
         if let dbType = databaseType, !PluginManager.shared.supportsReadOnlyMode(for: dbType) {
             effectiveIsWrite = true
         } else {
             effectiveIsWrite = isWriteOperation
         }
 
-        switch level {
+        switch effectiveLevel {
         case .silent:
             return .allowed
 

TablePro/Core/Services/Licensing/LicenseConstants.swift

@@ -0,0 +1,13 @@
+//
+//  LicenseConstants.swift
+//  TablePro
+//
+//  Shared constants for the licensing system.
+//
+
+import Foundation
+
+internal enum LicenseConstants {
+    // swiftlint:disable:next force_unwrapping
+    static let pricingURL = URL(string: "https://tablepro.app/#pricing")!
+}

TablePro/Core/Services/Licensing/LicenseManager.swift

@@ -246,21 +246,27 @@ final class LicenseManager {
 
     /// Evaluate current license status based on expiration, grace period, and signature validity
     private func evaluateStatus() {
+        let previousStatus = status
+
         guard let license else {
             status = .unlicensed
+            notifyIfChanged(from: previousStatus)
             return
         }
 
         // Check server-reported status
         switch license.status {
         case .suspended:
             status = .suspended
+            notifyIfChanged(from: previousStatus)
             return
         case .expired:
             status = .expired
+            notifyIfChanged(from: previousStatus)
             return
         case .deactivated:
             status = .deactivated
+            notifyIfChanged(from: previousStatus)
             return
         default:
             break
@@ -269,15 +275,24 @@ final class LicenseManager {
         // Check local expiration
         if license.isExpired {
             status = .expired
+            notifyIfChanged(from: previousStatus)
             return
         }
 
         // Check grace period
         if license.daysSinceLastValidation > gracePeriodDays {
             status = .validationFailed
+            notifyIfChanged(from: previousStatus)
             return
         }
 
         status = .active
+        notifyIfChanged(from: previousStatus)
+    }
+
+    private func notifyIfChanged(from previousStatus: LicenseStatus) {
+        if status != previousStatus {
+            NotificationCenter.default.post(name: .licenseStatusDidChange, object: nil)
+        }
     }
 }

TablePro/Core/Sync/SyncCoordinator.swift

@@ -26,6 +26,7 @@ final class SyncCoordinator {
     @ObservationIgnored private let conflictResolver = ConflictResolver.shared
     @ObservationIgnored private var accountObserver: NSObjectProtocol?
     @ObservationIgnored private var changeObserver: NSObjectProtocol?
+    @ObservationIgnored private var licenseObserver: NSObjectProtocol?
     @ObservationIgnored private var syncTask: Task<Void, Never>?
 
     private init() {
@@ -35,6 +36,7 @@ final class SyncCoordinator {
     deinit {
         if let accountObserver { NotificationCenter.default.removeObserver(accountObserver) }
         if let changeObserver { NotificationCenter.default.removeObserver(changeObserver) }
+        if let licenseObserver { NotificationCenter.default.removeObserver(licenseObserver) }
         syncTask?.cancel()
     }
 
@@ -44,6 +46,7 @@ final class SyncCoordinator {
     func start() {
         observeAccountChanges()
         observeLocalChanges()
+        observeLicenseChanges()
 
         // If local storage is empty (fresh install or wiped), clear the sync token
         // to force a full fetch instead of a delta that returns nothing
@@ -649,6 +652,23 @@ final class SyncCoordinator {
         }
     }
 
+    private func observeLicenseChanges() {
+        licenseObserver = NotificationCenter.default.addObserver(
+            forName: .licenseStatusDidChange,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            Task { @MainActor [weak self] in
+                guard let self else { return }
+                evaluateStatus()
+
+                if syncStatus.isEnabled {
+                    await syncNow()
+                }
+            }
+        }
+    }
+
     // MARK: - Account
 
     private func checkAccountStatus() async {

TablePro/Models/Connection/SafeModeLevel.swift

@@ -28,6 +28,13 @@ internal extension SafeModeLevel {
         }
     }
 
+    var requiresPro: Bool {
+        switch self {
+        case .safeMode, .safeModeFull, .readOnly: return true
+        case .silent, .alert, .alertFull: return false
+        }
+    }
+
     var blocksAllWrites: Bool {
         self == .readOnly
     }

TablePro/Models/Settings/License.swift

@@ -246,27 +246,54 @@ enum LicenseError: LocalizedError {
     var errorDescription: String? {
         switch self {
         case .invalidKey:
-            return "The license key is invalid."
+            return String(localized: "The license key is invalid.")
         case .signatureInvalid:
-            return "License signature verification failed."
+            return String(localized: "License signature verification failed.")
         case .publicKeyNotFound:
-            return "License public key not found in app bundle."
+            return String(localized: "License public key not found in app bundle.")
         case .publicKeyInvalid:
-            return "License public key is invalid."
+            return String(localized: "License public key is invalid.")
         case .activationLimitReached:
-            return "Maximum number of activations reached."
+            return String(localized: "Maximum number of activations reached.")
         case .licenseExpired:
-            return "The license has expired."
+            return String(localized: "The license has expired.")
         case .licenseSuspended:
-            return "The license has been suspended."
+            return String(localized: "The license has been suspended.")
         case .notActivated:
-            return "This machine is not activated."
+            return String(localized: "This machine is not activated.")
         case .networkError(let error):
-            return "Network error: \(error.localizedDescription)"
+            return String(localized: "Network error: \(error.localizedDescription)")
         case .serverError(let code, let message):
-            return "Server error (\(code)): \(message)"
+            return String(localized: "Server error (\(code)): \(message)")
         case .decodingError(let error):
-            return "Failed to parse server response: \(error.localizedDescription)"
+            return String(localized: "Failed to parse server response: \(error.localizedDescription)")
+        }
+    }
+
+    /// User-friendly description suitable for display in activation dialogs
+    var friendlyDescription: String {
+        switch self {
+        case .invalidKey:
+            return String(localized: "That doesn't look like a valid license key. Check for typos and try again.")
+        case .activationLimitReached:
+            return String(localized: "This license has reached its activation limit. Deactivate another Mac first.")
+        case .licenseExpired:
+            return String(localized: "This license has expired. Renew it to continue using Pro features.")
+        case .licenseSuspended:
+            return String(localized: "This license has been suspended. Contact support for help.")
+        case .networkError:
+            return String(localized: "Could not reach the license server. Check your internet connection and try again.")
+        case .serverError(let code, _):
+            if code == 422 {
+                return String(localized: "Invalid license key format. Check for typos and try again.")
+            }
+            return String(localized: "Something went wrong (error \(code)). Try again in a moment.")
+        case .signatureInvalid, .publicKeyNotFound, .publicKeyInvalid:
+            return String(localized: "License verification failed. Try updating the app to the latest version.")
+        case .notActivated:
+            return String(localized: "This machine is not activated for this license.")
+        case .decodingError:
+            return String(localized: "Could not read the server response. Try again in a moment.")
         }
     }
 }

TablePro/Models/Settings/ProFeature.swift

@@ -10,25 +10,39 @@ import Foundation
 /// Features that require a Pro (active) license
 internal enum ProFeature: String, CaseIterable {
     case iCloudSync
+    case safeMode
+    case xlsxExport
 
     var displayName: String {
         switch self {
         case .iCloudSync:
             return String(localized: "iCloud Sync")
+        case .safeMode:
+            return String(localized: "Safe Mode")
+        case .xlsxExport:
+            return String(localized: "XLSX Export")
         }
     }
 
     var systemImage: String {
         switch self {
         case .iCloudSync:
             return "icloud"
+        case .safeMode:
+            return "lock.shield"
+        case .xlsxExport:
+            return "tablecells"
         }
     }
 
     var featureDescription: String {
         switch self {
         case .iCloudSync:
             return String(localized: "Sync connections, settings, and history across your Macs.")
+        case .safeMode:
+            return String(localized: "Require confirmation or Touch ID before executing queries.")
+        case .xlsxExport:
+            return String(localized: "Export query results and tables to Excel format.")
         }
     }
 }