SPB Git

Repository Public

AppSession.swift 11.1 KB 266 lines swift

1import Foundation2import Observation34/// How an app builds the core: where the server is, where secrets go, who performs passkey ceremonies.5public struct CoreConfiguration: Sendable {6    public var origin: URL7    public var secureStore: any SecureStore8    public var passkeys: any PasskeyProvider9    /// Directory of the offline cache; nil disables it.10    public var cacheDirectory: URL?11    public var device: @Sendable () -> DeviceInfo1213    public init(origin: URL, secureStore: any SecureStore, passkeys: any PasskeyProvider, cacheDirectory: URL?,14                device: @escaping @Sendable () -> DeviceInfo = { DeviceInfo.current() }) {15        self.origin = origin; self.secureStore = secureStore; self.passkeys = passkeys16        self.cacheDirectory = cacheDirectory; self.device = device17    }1819    public static let productionOrigin = URL(string: "https://clustr.spboucher.ai")!20    public static let relyingPartyID = "clustr.spboucher.ai"21}2223/// Composition root shared by the macOS and iOS apps: API client, identity, event stream, offline cache and every24/// repository. The navigation shell (windows, tabs, split views) is the only thing a platform adds on top.25@MainActor26@Observable27public final class AppSession {28    public enum Phase: Sendable, Equatable {29        case starting30        case signedOut31        case signedIn32    }3334    public private(set) var phase: Phase = .starting35    /// Why the previous session ended, shown on the sign-in screen (nil after an ordinary sign-out).36    public private(set) var sessionEndError: APIError?37    public private(set) var streamState: StreamState = .idle38    public private(set) var connectivity = Connectivity.State()39    public private(set) var lastEventAt: Date?40    /// Incremented at every `resync` / full reload: views with local state can react to it.41    public private(set) var generation = 04243    @ObservationIgnored public let configuration: CoreConfiguration44    @ObservationIgnored public let api: APIClient45    @ObservationIgnored public let auth: AuthService46    @ObservationIgnored public let stream: EventStream47    @ObservationIgnored public let cache: OfflineCache?48    @ObservationIgnored public let gateway: Gateway4950    @ObservationIgnored public let account: AccountRepository51    @ObservationIgnored public let cluster: ClusterRepository52    @ObservationIgnored public let nodes: NodesRepository53    @ObservationIgnored public let services: ServicesRepository54    @ObservationIgnored public let models: ModelsRepository55    @ObservationIgnored public let jobs: JobsRepository56    @ObservationIgnored public let alerts: AlertsRepository57    @ObservationIgnored public let maintenance: MaintenanceRepository58    @ObservationIgnored public let actions: ActionsRepository59    @ObservationIgnored public let audit: AuditRepository60    @ObservationIgnored public let infrastructure: InfrastructureRepository61    @ObservationIgnored public let admin: AdminRepository6263    @ObservationIgnored private var watchers: [Task<Void, Never>] = []64    @ObservationIgnored private let pathObserver = PathObserver()65    @ObservationIgnored private var eventHandlers: [UUID: @MainActor (EventEnvelope) -> Void] = [:]66    @ObservationIgnored private var active = true67    @ObservationIgnored private var started = false6869    public init(configuration: CoreConfiguration, protocolClasses: [AnyClass]? = nil) {70        self.configuration = configuration71        let api = APIClient(origin: configuration.origin, secureStore: configuration.secureStore, protocolClasses: protocolClasses)72        self.api = api73        let auth = AuthService(api: api, passkeys: configuration.passkeys, device: configuration.device)74        self.auth = auth75        self.stream = EventStream(api: api, protocolClasses: protocolClasses)76        let cache = configuration.cacheDirectory.map { OfflineCache(directory: $0) }77        self.cache = cache78        let g = Gateway(api: api, auth: auth, cache: cache)79        self.gateway = g80        account = AccountRepository(g)81        cluster = ClusterRepository(g)82        nodes = NodesRepository(g)83        services = ServicesRepository(g)84        models = ModelsRepository(g)85        jobs = JobsRepository(g)86        alerts = AlertsRepository(g)87        maintenance = MaintenanceRepository(g)88        actions = ActionsRepository(g)89        audit = AuditRepository(g)90        infrastructure = InfrastructureRepository(g)91        admin = AdminRepository(g)92    }9394    // MARK: Derived state9596    public var me: API.Me? { account.me.value }97    public var user: API.User? { me?.user }98    public var permissions: Set<String> { Set(me?.permissions ?? []) }99    /// Mirrors what the server granted (`GET /me`). The UI only hides or disables with it; the server enforces.100    public func can(_ permission: String) -> Bool { permissions.contains(permission) }101    public var isOffline: Bool { connectivity.isOffline }102    public var offlineSince: Date? { connectivity.offlineSince }103    /// Mutations are disabled while offline: nothing dangerous is queued for later.104    public var canMutate: Bool { phase == .signedIn && !isOffline }105106    // MARK: Lifecycle107108    /// Restores the previous session, if any, and starts the watchers. Call once at launch.109    public func start() async {110        guard !started else { return }111        started = true112        watch()113        if await api.tokens.hasSession {114            await account.me.restoreIfNeeded()115            phase = .signedIn116            await sessionOpened()117        } else {118            phase = .signedOut119        }120    }121122    private func watch() {123        let api = self.api, stream = self.stream124        watchers.append(Task { [weak self] in125            for await reason in await api.tokens.sessionEnds() { await self?.sessionEnded(reason) }126        })127        watchers.append(Task { [weak self] in128            for await state in api.connectivity.updates() { await self?.connectivityChanged(state) }129        })130        watchers.append(Task { [weak self] in131            for await state in await stream.states() { await self?.setStreamState(state) }132        })133        watchers.append(Task { [weak self] in134            for await envelope in await stream.events() { await self?.handle(envelope) }135        })136        pathObserver.start(connectivity: api.connectivity) { [stream] satisfied in137            if satisfied { Task { await stream.reconnectNow() } }138        }139    }140141    private func setStreamState(_ s: StreamState) { streamState = s }142143    private func connectivityChanged(_ state: Connectivity.State) {144        let wasOffline = connectivity.isOffline145        connectivity = state146        if wasOffline && !state.isOffline && phase == .signedIn {147            // Back online: everything on screen may be outdated.148            reloadAll()149        }150    }151152    /// Passkey sign-in, then loads the account and opens the event stream.153    public func signIn() async throws {154        try await auth.signIn()155        await sessionOpened()156    }157158    /// Call after `auth.completeInvitation` (the setup flow opened the session itself).159    public func sessionOpened() async {160        sessionEndError = nil161        phase = .signedIn162        await account.me.load()163        if case .signedOut = phase { return }   // the load revealed a dead session164        if active { await stream.start() }165    }166167    public func signOut() async {168        await stream.stop()169        await auth.signOut()   // emits `.signedOut`, handled below170    }171172    private func sessionEnded(_ reason: SessionEndReason) async {173        await stream.stop()174        if case .refreshRejected(let e) = reason { sessionEndError = e } else { sessionEndError = nil }175        resetAll()176        await cache?.removeAll()177        phase = .signedOut178    }179180    /// App became active / inactive: the event stream follows.181    public func setActive(_ isActive: Bool) {182        active = isActive183        guard phase == .signedIn else { return }184        Task {185            if isActive { await stream.resume() } else { await stream.pause() }186        }187    }188189    // MARK: Events190191    /// Registers an observer of the typed events (notifications, live windows). Returns a token for `removeEventHandler`.192    @discardableResult193    public func addEventHandler(_ handler: @escaping @MainActor (EventEnvelope) -> Void) -> UUID {194        let id = UUID()195        eventHandlers[id] = handler196        return id197    }198199    public func removeEventHandler(_ id: UUID) { eventHandlers[id] = nil }200201    func handle(_ envelope: EventEnvelope) {202        lastEventAt = Date()203        switch envelope.event {204        case .nodeState(let e):205            nodes.apply(e)206            cluster.overview.scheduleReload(after: 3)207        case .nodeUpdated(let e):208            nodes.list.scheduleReload()209            nodes.detail.existing(e.nodeId)?.scheduleReload()210            cluster.overview.scheduleReload(after: 1)211        case .alertChanged(let e):212            alerts.apply(e)213            cluster.overview.scheduleReload(after: 1)214            nodes.list.scheduleReload(after: 1.5)   // open_alerts215            audit.activity.scheduleReload(after: 1)216        case .incidentChanged(let e):217            alerts.apply(e)218            cluster.overview.scheduleReload(after: 1)219        case .actionChanged(let e):220            actions.apply(e)221            cluster.overview.scheduleReload(after: 1)222            audit.activity.scheduleReload(after: 1)223        case .actionOutput(let e):224            actions.apply(e)225        case .serviceChanged(let e):226            services.apply(e)227            nodes.services.existing(e.nodeId)?.scheduleReload()228            cluster.overview.scheduleReload(after: 2)229        case .jobChanged(let e):230            jobs.apply(e)231            cluster.overview.scheduleReload(after: 2)232        case .maintenanceChanged(let e):233            maintenance.apply(e)234            if e.change == .occurrenceStarted || e.change == .occurrenceEnded { nodes.list.scheduleReload() }235            audit.activity.scheduleReload(after: 1)236        case .auditAppended:237            audit.entries.scheduleReloadAll()238        case .resync, .unknown:239            reloadAll()240        }241        for h in eventHandlers.values { h(envelope) }242    }243244    /// Reloads every read model something is looking at (resync, back online).245    public func reloadAll() {246        generation += 1247        account.me.scheduleReload()248        cluster.reloadActive(); nodes.reloadActive(); services.reloadActive(); models.reloadActive(); jobs.reloadActive()249        alerts.reloadActive(); maintenance.reloadActive(); actions.reloadActive(); audit.reloadActive(); infrastructure.reloadActive()250    }251252    private func resetAll() {253        account.reset(); cluster.reset(); nodes.reset(); services.reset(); models.reset(); jobs.reset(); alerts.reset()254        maintenance.reset(); actions.reset(); audit.reset(); infrastructure.reset(); admin.reset()255    }256257    // MARK: Search258259    /// Universal search (`GET /search`).260    public func search(_ query: String, kinds: [API.SearchResultKind]? = nil, limit: Int = 20) async throws -> [API.SearchResult] {261        let q = query.trimmingCharacters(in: .whitespacesAndNewlines)262        guard !q.isEmpty else { return [] }263        return try await gateway.read { try await $0.search(query: .init(q: q, kinds: kinds, limit: limit)).ok.body.json.items }264    }265}266
Files main
Menu

Theme