maksarsanjeev
396 lines
19 KiB
Swift
396 lines
19 KiB
Swift
#if PHONE_LINK
|
|
import AppKit
|
|
import CloudKit
|
|
import Combine
|
|
|
|
// MARK: - Services on the iPhone
|
|
//
|
|
// One `Service` record per service Mochi (GitHub, Stripe, Vercel, Resend,
|
|
// Cal.com, n8n, Notion), built from the data the Mac's pollers already keep in
|
|
// AppState: no extra API call, no key sent anywhere. The whole snapshot
|
|
// (amounts, titles, emails, links) is one field encrypted with the user's
|
|
// iCloud keys; only the pill ID, the state dot and the date are in clear.
|
|
// Driven by AppState changes (debounced), never by a timer.
|
|
|
|
@MainActor
|
|
final class ServicePublisher {
|
|
static let shared = ServicePublisher()
|
|
|
|
private let container = CKContainer(identifier: CloudProbe.containerID)
|
|
private var database: CKDatabase { container.privateCloudDatabase }
|
|
private var cancellable: AnyCancellable?
|
|
private var published: [String: ServiceSnapshot] = [:]
|
|
private var cleanedUp = false
|
|
private var writing = false
|
|
private var again = false
|
|
|
|
func start() {
|
|
guard cancellable == nil else { return }
|
|
let s = AppState.shared
|
|
let changes: [AnyPublisher<Void, Never>] = [
|
|
s.$stripePayments.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$stripeBalance.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$stripeError.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$githubPulse.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$githubActivity.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$vercelDeployments.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$resendEmails.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$calcomBookings.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$calcomError.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$notionPages.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$notionError.map { _ in () }.eraseToAnyPublisher(),
|
|
s.$n8nRuns.map { _ in () }.eraseToAnyPublisher(),
|
|
]
|
|
cancellable = Publishers.MergeMany(changes)
|
|
.debounce(for: .seconds(2), scheduler: RunLoop.main)
|
|
.sink { [weak self] in
|
|
MainActor.assumeIsolated { self?.publish() }
|
|
}
|
|
log("service publisher on")
|
|
}
|
|
|
|
/// Stops and deletes this Mac's services from iCloud.
|
|
func stop() {
|
|
cancellable = nil
|
|
let ids = PillCatalog.phoneServices.map {
|
|
CKRecord.ID(recordName: ServiceSnapshot.recordName(for: $0), zoneID: SessionSnapshot.zoneID)
|
|
}
|
|
published = [:]
|
|
cleanedUp = false
|
|
Task { _ = try? await database.modifyRecords(saving: [], deleting: ids, savePolicy: .changedKeys, atomically: false) }
|
|
log("service publisher off")
|
|
}
|
|
|
|
private func publish() {
|
|
guard !writing else { again = true; return }
|
|
writing = true
|
|
let snapshots = ServiceSnapshots.all(from: AppState.shared)
|
|
Task {
|
|
await write(snapshots)
|
|
writing = false
|
|
if again { again = false; publish() }
|
|
}
|
|
}
|
|
|
|
private func write(_ snapshots: [String: ServiceSnapshot]) async {
|
|
var deletions: [CKRecord.ID] = []
|
|
if !cleanedUp {
|
|
// Services this Mac no longer has (key removed since the last run).
|
|
deletions = PillCatalog.phoneServices.filter { snapshots[$0] == nil }.map {
|
|
CKRecord.ID(recordName: ServiceSnapshot.recordName(for: $0), zoneID: SessionSnapshot.zoneID)
|
|
}
|
|
cleanedUp = true
|
|
}
|
|
let changed = snapshots.values.filter { snapshot in
|
|
guard let old = published[snapshot.pillId] else { return true }
|
|
return !old.sameContent(as: snapshot)
|
|
}
|
|
let removed = published.keys.filter { snapshots[$0] == nil }
|
|
deletions += removed.map { CKRecord.ID(recordName: ServiceSnapshot.recordName(for: $0), zoneID: SessionSnapshot.zoneID) }
|
|
guard !changed.isEmpty || !deletions.isEmpty else { return }
|
|
|
|
let records = changed.compactMap { record(for: $0) }
|
|
do {
|
|
let result = try await database.modifyRecords(saving: records, deleting: deletions,
|
|
savePolicy: .changedKeys, atomically: false)
|
|
for (id, outcome) in result.saveResults {
|
|
guard let pillId = ServiceSnapshot.pillId(fromRecordName: id.recordName) else { continue }
|
|
if case .success = outcome { published[pillId] = snapshots[pillId] }
|
|
}
|
|
for id in removed { published[id] = nil }
|
|
let names = changed.map { "\($0.pillId.replacingOccurrences(of: "integration_", with: ""))=\($0.tone.rawValue)" }
|
|
log("published \(changed.count) service(s) [\(names.sorted().joined(separator: ", "))], removed \(deletions.count)")
|
|
} catch {
|
|
log("publish failed: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
private func record(for snapshot: ServiceSnapshot) -> CKRecord? {
|
|
guard let json = try? JSONEncoder().encode(snapshot), let payload = String(data: json, encoding: .utf8) else { return nil }
|
|
let record = CKRecord(recordType: ServiceSnapshot.recordType,
|
|
recordID: CKRecord.ID(recordName: ServiceSnapshot.recordName(for: snapshot.pillId),
|
|
zoneID: SessionSnapshot.zoneID))
|
|
record["pillId"] = snapshot.pillId
|
|
record["tone"] = snapshot.tone.rawValue
|
|
record["updatedAt"] = snapshot.updatedAt
|
|
record["macName"] = Host.current().localizedName ?? ""
|
|
record.encryptedValues["payload"] = payload
|
|
return record
|
|
}
|
|
|
|
private func log(_ message: String) {
|
|
CloudProbe.shared.log("[services] \(message)")
|
|
}
|
|
}
|
|
|
|
// MARK: - Building the snapshots
|
|
|
|
/// One snapshot per service that has data on this Mac. A service without its
|
|
/// key (nothing loaded) is left out, and the iPhone shows "connect it on your Mac".
|
|
@MainActor
|
|
enum ServiceSnapshots {
|
|
static func all(from s: AppState) -> [String: ServiceSnapshot] {
|
|
let built = [github(s), stripe(s), vercel(s), resend(s), calcom(s), n8n(s), notion(s)].compactMap { $0 }
|
|
return Dictionary(uniqueKeysWithValues: built.map { ($0.pillId, $0) })
|
|
}
|
|
|
|
// MARK: GitHub
|
|
|
|
static func github(_ s: AppState) -> ServiceSnapshot? {
|
|
guard let pulse = s.githubPulse else { return nil }
|
|
func tone(_ ci: CIState) -> ServiceTone {
|
|
switch ci {
|
|
case .success: .ok
|
|
case .failure: .error
|
|
case .pending: .warning
|
|
case .unknown: .idle
|
|
}
|
|
}
|
|
func ciLabel(_ ci: CIState) -> String {
|
|
switch ci {
|
|
case .success: "checks passed"
|
|
case .failure: "checks failing"
|
|
case .pending: "checks running"
|
|
case .unknown: "no checks"
|
|
}
|
|
}
|
|
func reviewLabel(_ review: ReviewState) -> String {
|
|
switch review {
|
|
case .approved: " · approved"
|
|
case .changesRequested: " · changes requested"
|
|
case .pending: " · review required"
|
|
case .unknown: ""
|
|
}
|
|
}
|
|
let failingPR = pulse.myPRs.first { $0.ci == .failure }
|
|
let failingMain = pulse.mainCI.first { $0.ci == .failure }
|
|
let pending = pulse.myPRs.contains { $0.ci == .pending } || pulse.mainCI.contains { $0.ci == .pending }
|
|
let anyGreen = pulse.myPRs.contains { $0.ci == .success } || pulse.mainCI.contains { $0.ci == .success }
|
|
|
|
let overall: ServiceTone
|
|
let reason: String
|
|
if let main = failingMain {
|
|
overall = .error
|
|
reason = "CI failing on \(main.repo) · \(main.branch)"
|
|
} else if let pr = failingPR {
|
|
overall = .error
|
|
reason = "Checks failing on \(pr.repo) #\(pr.number): \(pr.title)"
|
|
} else if pending {
|
|
overall = .warning
|
|
reason = "Checks are running"
|
|
} else if !pulse.toReview.isEmpty {
|
|
overall = .warning
|
|
reason = pulse.toReview.count == 1
|
|
? "1 pull request waits for your review"
|
|
: "\(pulse.toReview.count) pull requests wait for your review"
|
|
} else if anyGreen {
|
|
overall = .ok
|
|
reason = "All checks passed"
|
|
} else {
|
|
overall = .idle
|
|
reason = "Nothing going on"
|
|
}
|
|
|
|
var sections: [ServiceSection] = []
|
|
if !pulse.myPRs.isEmpty {
|
|
sections.append(ServiceSection(title: "Your pull requests", items: pulse.myPRs.prefix(8).map {
|
|
ServiceItem(title: "#\($0.number) \($0.title)",
|
|
detail: "\($0.repo) · \(ciLabel($0.ci))\(reviewLabel($0.review))\($0.isDraft ? " · draft" : "")",
|
|
tone: tone($0.ci), url: $0.url)
|
|
}))
|
|
}
|
|
if !pulse.toReview.isEmpty {
|
|
sections.append(ServiceSection(title: "Waiting for your review", items: pulse.toReview.prefix(8).map {
|
|
ServiceItem(title: "#\($0.number) \($0.title)", detail: $0.repo, tone: .warning, url: $0.url)
|
|
}))
|
|
}
|
|
if !pulse.mainCI.isEmpty {
|
|
sections.append(ServiceSection(title: "Default branches", items: pulse.mainCI.prefix(8).map {
|
|
ServiceItem(title: $0.repo, detail: "\($0.branch) · \(ciLabel($0.ci))", tone: tone($0.ci), url: $0.url)
|
|
}))
|
|
}
|
|
var headline = "\(pulse.myPRs.count) open pull request\(pulse.myPRs.count == 1 ? "" : "s")"
|
|
if let total = s.githubActivity?.total { headline += " · \(total) contributions this year" }
|
|
return ServiceSnapshot(pillId: "integration_github", tone: overall, headline: headline, reason: reason,
|
|
sections: sections, updatedAt: pulse.fetchedAt)
|
|
}
|
|
|
|
// MARK: Stripe
|
|
|
|
static func stripe(_ s: AppState) -> ServiceSnapshot? {
|
|
if let error = s.stripeError, !s.stripeLoaded {
|
|
return ServiceSnapshot(pillId: "integration_stripe", tone: .error, headline: "Can't reach Stripe",
|
|
reason: error, sections: [], updatedAt: Date())
|
|
}
|
|
guard s.stripeLoaded else { return nil }
|
|
let currency = s.stripeCurrency.uppercased()
|
|
func money(_ cents: Int, _ code: String) -> String {
|
|
String(format: "%.2f %@", Double(cents) / 100, code.uppercased())
|
|
}
|
|
let latest = s.stripePayments.first
|
|
let overall: ServiceTone
|
|
let reason: String
|
|
if let error = s.stripeError {
|
|
overall = .error
|
|
reason = "Stripe answered with an error: \(error)"
|
|
} else if let latest {
|
|
let what = latest.description.map { " · \($0)" } ?? ""
|
|
switch latest.status {
|
|
case "succeeded":
|
|
overall = Date().timeIntervalSince(latest.createdAt) < 86_400 ? .ok : .idle
|
|
reason = "Last payment received: \(money(latest.amount, latest.currency))\(what)"
|
|
case "failed":
|
|
overall = .error
|
|
reason = "Last payment failed: \(money(latest.amount, latest.currency))\(what)"
|
|
default:
|
|
overall = .warning
|
|
reason = "Last payment pending: \(money(latest.amount, latest.currency))\(what)"
|
|
}
|
|
} else {
|
|
overall = .idle
|
|
reason = "No payment yet"
|
|
}
|
|
let items = s.stripePayments.prefix(10).map {
|
|
ServiceItem(title: money($0.amount, $0.currency),
|
|
detail: [$0.description, $0.status].compactMap { $0 }.joined(separator: " · "),
|
|
tone: $0.isSuccess ? .ok : ($0.status == "failed" ? .error : .warning),
|
|
date: $0.createdAt)
|
|
}
|
|
return ServiceSnapshot(pillId: "integration_stripe", tone: overall,
|
|
headline: "Balance \(money(s.stripeBalance, currency))", reason: reason,
|
|
sections: items.isEmpty ? [] : [ServiceSection(title: "Recent payments", items: items)],
|
|
updatedAt: latest?.createdAt ?? Date())
|
|
}
|
|
|
|
// MARK: Vercel
|
|
|
|
static func vercel(_ s: AppState) -> ServiceSnapshot? {
|
|
let filter = s.vercelProjectFilter
|
|
let deployments = filter.isEmpty ? s.vercelDeployments : s.vercelDeployments.filter { filter.contains($0.projectName) }
|
|
guard let latest = deployments.first else { return nil }
|
|
func tone(_ d: VercelDeployment) -> ServiceTone {
|
|
d.isSuccess ? .ok : (d.state == "CANCELED" ? .warning : .error)
|
|
}
|
|
let branch = latest.branch.map { " · \($0)" } ?? ""
|
|
let reason: String
|
|
switch latest.state {
|
|
case "READY": reason = "Last deploy is live: \(latest.projectName)\(branch)"
|
|
case "CANCELED": reason = "Last deploy was canceled: \(latest.projectName)\(branch)"
|
|
default: reason = "Last deploy failed: \(latest.projectName)\(branch)"
|
|
}
|
|
let items = deployments.prefix(10).map { d in
|
|
ServiceItem(title: d.projectName,
|
|
detail: [d.statusLabel, d.branch, d.commitMessage].compactMap { $0 }.joined(separator: " · "),
|
|
tone: tone(d), date: d.createdAt,
|
|
url: d.url.isEmpty ? nil : "https://\(d.url)")
|
|
}
|
|
return ServiceSnapshot(pillId: "integration_vercel", tone: tone(latest),
|
|
headline: "\(latest.projectName) · \(latest.statusLabel)", reason: reason,
|
|
sections: [ServiceSection(title: "Deployments", items: items)],
|
|
updatedAt: latest.createdAt)
|
|
}
|
|
|
|
// MARK: Resend
|
|
|
|
static func resend(_ s: AppState) -> ServiceSnapshot? {
|
|
guard let latest = s.resendEmails.first else { return nil }
|
|
func tone(_ event: String) -> ServiceTone {
|
|
switch event {
|
|
case "bounced", "complained", "failed": .error
|
|
case "delivered", "opened", "clicked": .ok
|
|
case "delivery_delayed": .warning
|
|
default: .info
|
|
}
|
|
}
|
|
let reason: String
|
|
switch tone(latest.lastEvent) {
|
|
case .error: reason = "Last email \(latest.lastEvent): \(latest.subject)"
|
|
case .warning: reason = "Last email is delayed: \(latest.subject)"
|
|
case .ok: reason = "Last email \(latest.lastEvent): \(latest.subject)"
|
|
default: reason = "Last email \(latest.lastEvent): \(latest.subject)"
|
|
}
|
|
let items = s.resendEmails.prefix(10).map {
|
|
ServiceItem(title: $0.subject, detail: "to \($0.to.joined(separator: ", ")) · \($0.lastEvent)",
|
|
tone: tone($0.lastEvent), date: $0.createdAt)
|
|
}
|
|
let total = s.resendTotal.map { "\($0) emails sent" } ?? "Emails"
|
|
return ServiceSnapshot(pillId: "integration_resend", tone: tone(latest.lastEvent), headline: total,
|
|
reason: reason, sections: [ServiceSection(title: "Recent emails", items: items)],
|
|
updatedAt: latest.createdAt)
|
|
}
|
|
|
|
// MARK: Cal.com
|
|
|
|
static func calcom(_ s: AppState) -> ServiceSnapshot? {
|
|
if let error = s.calcomError, !s.calcomLoaded {
|
|
return ServiceSnapshot(pillId: "integration_calcom", tone: .error, headline: "Can't reach Cal.com",
|
|
reason: error, sections: [], updatedAt: Date())
|
|
}
|
|
guard s.calcomLoaded else { return nil }
|
|
let upcoming = s.calcomBookings.filter { $0.endTime > Date() }.sorted { $0.startTime < $1.startTime }
|
|
let next = upcoming.first { $0.isActive }
|
|
let time = Date.FormatStyle(date: .abbreviated, time: .shortened)
|
|
let overall: ServiceTone
|
|
let reason: String
|
|
if let next {
|
|
let soon = next.startTime.timeIntervalSinceNow < 3600
|
|
overall = soon ? .warning : .info
|
|
let with = next.attendeeName.map { " with \($0)" } ?? ""
|
|
reason = "\(soon ? "Starting soon" : "Next"): \(next.title)\(with), \(next.startTime.formatted(time))"
|
|
} else {
|
|
overall = .idle
|
|
reason = "No upcoming booking"
|
|
}
|
|
let items = upcoming.prefix(10).map {
|
|
ServiceItem(title: $0.title,
|
|
detail: [$0.attendeeName, $0.status.lowercased()].compactMap { $0 }.joined(separator: " · "),
|
|
tone: $0.isActive ? .info : .idle, date: $0.startTime)
|
|
}
|
|
let count = upcoming.filter(\.isActive).count
|
|
return ServiceSnapshot(pillId: "integration_calcom", tone: overall,
|
|
headline: "\(count) upcoming booking\(count == 1 ? "" : "s")", reason: reason,
|
|
sections: items.isEmpty ? [] : [ServiceSection(title: "Upcoming", items: items)],
|
|
updatedAt: Date())
|
|
}
|
|
|
|
// MARK: n8n
|
|
|
|
static func n8n(_ s: AppState) -> ServiceSnapshot? {
|
|
guard let latest = s.n8nRuns.first else { return nil }
|
|
let reason = latest.success
|
|
? "Last run succeeded: \(latest.workflow)"
|
|
: "Last run failed: \(latest.workflow)\(latest.detail.map { " · \($0)" } ?? "")"
|
|
let items = s.n8nRuns.map {
|
|
ServiceItem(title: $0.workflow, detail: $0.detail ?? ($0.success ? "succeeded" : "failed"),
|
|
tone: $0.success ? .ok : .error, date: $0.date)
|
|
}
|
|
let failed = s.n8nRuns.filter { !$0.success }.count
|
|
return ServiceSnapshot(pillId: "integration_n8n", tone: latest.success ? .ok : .error,
|
|
headline: failed == 0 ? "All recent runs succeeded" : "\(failed) failed run\(failed == 1 ? "" : "s")",
|
|
reason: reason, sections: [ServiceSection(title: "Recent runs", items: items)],
|
|
updatedAt: latest.date)
|
|
}
|
|
|
|
// MARK: Notion
|
|
|
|
static func notion(_ s: AppState) -> ServiceSnapshot? {
|
|
if let error = s.notionError, !s.notionLoaded {
|
|
return ServiceSnapshot(pillId: "integration_notion", tone: .error, headline: "Can't reach Notion",
|
|
reason: error, sections: [], updatedAt: Date())
|
|
}
|
|
guard s.notionLoaded else { return nil }
|
|
let pages = s.notionPages.sorted { $0.lastEditedAt > $1.lastEditedAt }
|
|
let items = pages.prefix(10).map {
|
|
ServiceItem(title: [$0.emoji, $0.title].compactMap { $0 }.joined(separator: " "),
|
|
tone: .info, date: $0.lastEditedAt, url: $0.url)
|
|
}
|
|
let reason = pages.first.map { "Last edited: \($0.title)" } ?? "No recent page"
|
|
let recent = (pages.first?.lastEditedAt.timeIntervalSinceNow ?? -.infinity) > -3600
|
|
return ServiceSnapshot(pillId: "integration_notion", tone: recent ? .info : .idle,
|
|
headline: "\(pages.count) recent page\(pages.count == 1 ? "" : "s")", reason: reason,
|
|
sections: items.isEmpty ? [] : [ServiceSection(title: "Recently edited", items: items)],
|
|
updatedAt: pages.first?.lastEditedAt ?? Date())
|
|
}
|
|
}
|
|
#endif
|