Skip to content

A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.

47.5 KB
Raw Blame
#if PHONE_LINK
import AppKit
import CloudKit

// MARK: - Services up close, for the iPhone
//
// When a service's screen opens on the iPhone, it writes a `ServiceAction`
// record of kind "refresh"; to act (redeploy, re-run, merge…) it writes one
// with that action's kind and target. The CloudKit push wakes this Mac (with
// a check every minute in case a push is missed); it takes each request once
// (deleted on read, and only those it could delete), reads the service's API
// with the key in its Keychain and writes a `ServiceDetail` record,
// encrypted. An action runs only if it was offered on an item of the last
// detail sent for that service, and was asked for in the last 5 minutes.
// Nothing that moves money or sends an email is ever offered.

@MainActor
final class ServiceDetailRunner {
    static let shared = ServiceDetailRunner()

    private var database: CKDatabase { CKContainer(identifier: CloudProbe.containerID).privateCloudDatabase }
    private var pollTask: Task<Void, Never>?
    private var changeToken: CKServerChangeToken?
    /// The last detail sent per service: actions are checked against it.
    private var lastDetails: [String: ServiceDetail] = [:]
    private let maxAge: TimeInterval = 5 * 60
    private var checking = false
    private var again = false

    func start() {
        guard pollTask == nil else { return }
        pollTask = Task { [weak self] in
            while !Task.isCancelled {
                await self?.checkNow()
                // In case a push is missed.
                try? await Task.sleep(for: .seconds(60))
            }
        }
    }

    /// Stops and deletes the details this Mac wrote to iCloud.
    func stop() {
        pollTask?.cancel()
        pollTask = nil
        lastDetails = [:]
        let ids = PillCatalog.phoneServices.map {
            CKRecord.ID(recordName: ServiceDetail.recordName(for: $0), zoneID: SessionSnapshot.zoneID)
        }
        Task { _ = try? await database.modifyRecords(saving: [], deleting: ids, savePolicy: .changedKeys, atomically: false) }
    }

    /// From the CloudKit push and the fallback check. One check at a time: two
    /// overlapping checks would share the change token and could run an action twice.
    func checkNow() async {
        guard pollTask != nil else { return }
        guard !checking else { again = true; return }
        checking = true
        repeat {
            again = false
            await check()
        } while again
        checking = false
    }

    // MARK: Requests

    private func check() async {
        var found: [CKRecord] = []
        do {
            var more = true
            while more {
                let changes = try await database.recordZoneChanges(inZoneWith: SessionSnapshot.zoneID, since: changeToken,
                                                                   desiredKeys: ["pillId", "kind", "requestedAt", "target"])
                for (_, result) in changes.modificationResultsByID {
                    if case .success(let mod) = result, mod.record.recordType == ServiceDetail.requestType {
                        found.append(mod.record)
                    }
                }
                changeToken = changes.changeToken
                more = changes.moreComing
            }
        } catch let error as CKError where error.code == .changeTokenExpired {
            changeToken = nil
            return
        } catch {
            return
        }
        guard !found.isEmpty else { return }
        // Single use: act only on the requests this Mac actually removed from iCloud.
        guard let removed = try? await database.modifyRecords(saving: [], deleting: found.map(\.recordID),
                                                              savePolicy: .changedKeys, atomically: false) else {
            log("couldn't take \(found.count) request(s) off iCloud; skipped")
            return
        }
        let taken = found.filter {
            guard case .success? = removed.deleteResults[$0.recordID] else { return false }
            return true
        }

        // Several refreshes for one service count once.
        var refreshed: Set<String> = []
        for record in taken.sorted(by: { ($0["requestedAt"] as? Date ?? .distantPast) < ($1["requestedAt"] as? Date ?? .distantPast) }) {
            let pillId = record["pillId"] as? String ?? ""
            let kind = record["kind"] as? String ?? ""
            let target = record.encryptedValues["target"] as? String ?? ""
            let requestedAt = record["requestedAt"] as? Date ?? .distantPast
            guard Date().timeIntervalSince(requestedAt) < maxAge, PillCatalog.phoneServices.contains(pillId) else { continue }
            if kind == ServiceDetail.refreshKind {
                guard refreshed.insert(pillId).inserted else { continue }
                await publish(pillId: pillId, lastAction: lastDetails[pillId]?.lastAction)
            } else {
                await run(kind: kind, target: target, pillId: pillId)
            }
        }
    }

    private func run(kind: String, target: String, pillId: String) async {
        guard let action = lastDetails[pillId]?.offered(kind: kind, target: target),
              ServiceAPI.allowedKinds.contains(kind), kind.hasPrefix(ServiceAPI.prefix(of: pillId)) else {
            log("ignored an action that wasn't offered: \(kind)")
            await publish(pillId: pillId, lastAction: ServiceActionResult(
                title: "Not done", ok: false,
                message: "This action isn't offered any more. The list was refreshed.", date: Date()))
            return
        }
        log("\(action.title) (\(pillId)) asked from the iPhone")
        let result: ServiceActionResult
        do {
            let message = try await ServiceAPI.perform(kind: kind, target: target)
            result = ServiceActionResult(title: action.title, ok: true, message: message, date: Date())
        } catch {
            result = ServiceActionResult(title: action.title, ok: false, message: ServiceAPI.describe(error), date: Date())
        }
        log("\(action.title): \(result.ok ? "done" : "failed, \(result.message)")")
        // Give the service a moment, then show where things are.
        try? await Task.sleep(for: .seconds(2))
        await publish(pillId: pillId, lastAction: result)
    }

    private func publish(pillId: String, lastAction: ServiceActionResult?) async {
        var detail = await ServiceAPI.detail(for: pillId)
        // The iPhone sync was turned off while the API was read: write nothing.
        guard !Task.isCancelled, pollTask != nil else { return }
        detail.lastAction = lastAction
        lastDetails[pillId] = detail
        guard let json = try? JSONEncoder().encode(detail), let payload = String(data: json, encoding: .utf8) else { return }
        let record = CKRecord(recordType: ServiceDetail.recordType,
                              recordID: CKRecord.ID(recordName: ServiceDetail.recordName(for: pillId), zoneID: SessionSnapshot.zoneID))
        record["pillId"] = pillId
        record["fetchedAt"] = detail.fetchedAt
        record.encryptedValues["payload"] = payload
        do {
            _ = try await database.modifyRecords(saving: [record], deleting: [], savePolicy: .allKeys)
        } catch {
            log("detail for \(pillId) not saved: \(error.localizedDescription)")
        }
    }

    private func log(_ message: String) {
        CloudProbe.shared.log("[services] \(message)")
    }
}

// MARK: - The services' APIs

enum ServiceAPI {
    struct Failure: Error {
        let status: Int
        let message: String
    }

    /// Every action the iPhone can ask for. Nothing moves money or sends an email.
    static let allowedKinds: Set<String> = [
        "vercel.redeploy", "vercel.promote", "vercel.cancel",
        "github.rerun", "github.approve", "github.merge",
        "n8n.activate", "n8n.deactivate", "n8n.retry",
    ]

    static func prefix(of pillId: String) -> String {
        pillId.replacingOccurrences(of: "integration_", with: "") + "."
    }

    static func describe(_ error: Error) -> String {
        if let failure = error as? Failure {
            switch failure.status {
            case 401:
                if failure.message.localizedCaseInsensitiveContains("restricted") {
                    // Resend `restricted_api_key`: a Sending-access key can't read emails or domains.
                    return "This key can only send emails. Use a Full access key in Coucou's Settings on your Mac to see them here."
                }
                return "The key was refused (401). Check it in Coucou's Settings on your Mac."
            case 403: return "Not allowed with this key (403). \(failure.message)"
            case 404: return "Not found (404)."
            default: return failure.message.isEmpty ? "Error \(failure.status)" : String(failure.message.prefix(160))
            }
        }
        return error.localizedDescription
    }

    // MARK: HTTP

    private static func request(_ urlString: String, method: String = "GET", headers: [String: String],
                                body: [String: Any]? = nil) async throws -> Any {
        guard let url = URL(string: urlString) else { throw Failure(status: 0, message: "Bad address") }
        var request = URLRequest(url: url, timeoutInterval: 15)
        request.httpMethod = method
        for (key, value) in headers { request.setValue(value, forHTTPHeaderField: key) }
        if let body {
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.httpBody = try JSONSerialization.data(withJSONObject: body)
        }
        let (data, response) = try await URLSession.shared.data(for: request)
        let status = (response as? HTTPURLResponse)?.statusCode ?? 0
        guard (200..<300).contains(status) else {
            let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
            let message = (json?["message"] as? String)
                ?? ((json?["error"] as? [String: Any])?["message"] as? String)
                ?? (json?["error"] as? String)
                ?? String(decoding: data.prefix(200), as: UTF8.self)
            throw Failure(status: status, message: message)
        }
        if data.isEmpty { return [String: Any]() }
        return try JSONSerialization.jsonObject(with: data)
    }

    private static func date(_ value: Any?) -> Date? {
        if let ms = value as? Double { return Date(timeIntervalSince1970: ms > 1e11 ? ms / 1000 : ms) }
        if let ms = value as? Int { return Date(timeIntervalSince1970: ms > 100_000_000_000 ? Double(ms) / 1000 : Double(ms)) }
        guard let text = value as? String else { return nil }
        let fractional = ISO8601DateFormatter()
        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        if let date = fractional.date(from: text) { return date }
        let plain = ISO8601DateFormatter()
        if let date = plain.date(from: text) { return date }
        // Resend: "2024-05-01 10:00:00.123456+00"
        let formatter = DateFormatter()
        formatter.locale = Locale(identifier: "en_US_POSIX")
        for format in ["yyyy-MM-dd HH:mm:ss.SSSSSSZ", "yyyy-MM-dd HH:mm:ss.SSSZ", "yyyy-MM-dd HH:mm:ssZ"] {
            formatter.dateFormat = format
            if let date = formatter.date(from: text.count > 3 && text.hasSuffix("+00") ? text + "00" : text) { return date }
        }
        return nil
    }

    private static func money(_ cents: Int, _ currency: String) -> String {
        let formatter = NumberFormatter()
        formatter.numberStyle = .currency
        formatter.currencyCode = currency.uppercased()
        // Stripe zero-decimal currencies (docs.stripe.com/currencies#zero-decimal). UGX and ISK stay ×100
        // for backward compatibility; HUF and TWD charges are two-decimal.
        let zeroDecimal: Set<String> = ["bif", "clp", "djf", "gnf", "jpy", "kmf", "krw", "mga", "pyg", "rwf",
                                        "vnd", "vuv", "xaf", "xof", "xpf"]
        let amount = zeroDecimal.contains(currency.lowercased()) ? Double(cents) : Double(cents) / 100
        return formatter.string(from: NSNumber(value: amount)) ?? "\(amount) \(currency.uppercased())"
    }

    // MARK: Reading

    static func detail(for pillId: String) async -> ServiceDetail {
        do {
            switch pillId {
            case "integration_vercel": return try await vercel()
            case "integration_github": return try await github()
            case "integration_stripe": return try await stripe()
            case "integration_resend": return try await resend()
            case "integration_calcom": return try await calcom()
            case "integration_n8n": return try await n8n()
            case "integration_notion": return try await notion()
            default: return ServiceDetail(pillId: pillId, fetchedAt: Date(), error: "Not available from the iPhone yet.")
            }
        } catch {
            return ServiceDetail(pillId: pillId, fetchedAt: Date(), error: describe(error))
        }
    }

    private static func secret(_ name: String, _ service: String) throws -> String {
        guard let value = KeychainStore.shared.get(name), !value.isEmpty else {
            throw Failure(status: 0, message: "No \(service) key on your Mac. Add it in Coucou's Settings.")
        }
        return value
    }

    // Vercel: deployments (redeploy, promote to production, cancel) and projects.
    private static func vercel() async throws -> ServiceDetail {
        let token = try secret("vercel-token", "Vercel")
        let headers = ["Authorization": "Bearer \(token)", "Accept": "application/json"]
        let deploymentsJSON = try await request("https://api.vercel.com/v6/deployments?limit=20", headers: headers)
        let deployments = (deploymentsJSON as? [String: Any])?["deployments"] as? [[String: Any]] ?? []
        let projectsJSON = try? await request("https://api.vercel.com/v9/projects?limit=20", headers: headers)
        let projects = (projectsJSON as? [String: Any])?["projects"] as? [[String: Any]] ?? []

        var items: [DetailItem] = []
        var ready = 0, failed = 0, building = 0
        for d in deployments {
            guard let uid = d["uid"] as? String else { continue }
            let name = d["name"] as? String ?? "Deployment"
            let state = (d["state"] as? String ?? d["readyState"] as? String ?? "").uppercased()
            let target = d["target"] as? String
            let meta = d["meta"] as? [String: Any] ?? [:]
            let message = meta["githubCommitMessage"] as? String ?? ""
            let branch = meta["githubCommitRef"] as? String ?? ""
            let creator = (d["creator"] as? [String: Any])?["username"] as? String ?? ""
            var tone: ServiceTone = .idle
            var actions: [ServiceActionDef] = []
            switch state {
            case "READY":
                ready += 1
                tone = .ok
                actions.append(ServiceActionDef(kind: "vercel.redeploy", title: "Redeploy", symbol: "arrow.clockwise",
                                                target: "\(uid)|\(name)|\(target ?? "")"))
                if target != "production" {
                    actions.append(ServiceActionDef(kind: "vercel.promote", title: "Promote to production",
                                                    symbol: "arrow.up.circle", target: "\(uid)|\(name)",
                                                    confirm: "A new production build starts from this deployment, using your production environment variables."))
                }
            case "ERROR":
                failed += 1
                tone = .error
                actions.append(ServiceActionDef(kind: "vercel.redeploy", title: "Redeploy", symbol: "arrow.clockwise",
                                                target: "\(uid)|\(name)|\(target ?? "")"))
            case "BUILDING", "QUEUED", "INITIALIZING":
                building += 1
                tone = .warning
                actions.append(ServiceActionDef(kind: "vercel.cancel", title: "Cancel build", symbol: "xmark.circle",
                                                target: uid, destructive: true, confirm: "Stop this build?"))
            case "CANCELED": tone = .idle
            default: break
            }
            let subtitle = [branch, message.split(separator: "\n").first.map(String.init) ?? "", creator]
                .filter { !$0.isEmpty }.joined(separator: " · ")
            items.append(DetailItem(title: name, subtitle: subtitle.isEmpty ? state.capitalized : subtitle, tone: tone,
                                    date: date(d["created"] ?? d["createdAt"]),
                                    url: (d["url"] as? String).map { "https://\($0)" },
                                    badge: target == "production" ? "Production" : (state == "READY" ? "Preview" : state.capitalized),
                                    actions: actions))
        }
        let projectItems = projects.prefix(20).map { p in
            DetailItem(title: p["name"] as? String ?? "Project",
                       subtitle: (p["framework"] as? String).map { $0.capitalized } ?? "",
                       date: date(p["updatedAt"]))
        }
        var sections = [DetailSection(title: "Deployments", items: items)]
        if !projectItems.isEmpty { sections.append(DetailSection(title: "Projects · \(projectItems.count)", items: Array(projectItems))) }
        return ServiceDetail(pillId: "integration_vercel",
                             stats: [DetailStat(label: "Ready", value: "\(ready)", tone: .ok),
                                     DetailStat(label: "Building", value: "\(building)", tone: building > 0 ? .warning : .idle),
                                     DetailStat(label: "Failed", value: "\(failed)", tone: failed > 0 ? .error : .idle),
                                     DetailStat(label: "Projects", value: "\(projects.count)")],
                             sections: sections, fetchedAt: Date())
    }

    // GitHub: your pull requests (merge), reviews asked of you (approve), CI runs (re-run failed jobs).
    private static func github() async throws -> ServiceDetail {
        let token = try secret("github-token", "GitHub")
        let headers = ["Authorization": "Bearer \(token)", "Accept": "application/vnd.github+json",
                       "X-GitHub-Api-Version": "2022-11-28"]
        let user = try await request("https://api.github.com/user", headers: headers) as? [String: Any] ?? [:]
        let login = user["login"] as? String ?? ""

        func search(_ query: String) async -> [[String: Any]] {
            var components = URLComponents(string: "https://api.github.com/search/issues")!
            components.queryItems = [URLQueryItem(name: "q", value: query), URLQueryItem(name: "per_page", value: "10"),
                                     URLQueryItem(name: "sort", value: "updated")]
            let json = try? await request(components.url!.absoluteString, headers: headers)
            return (json as? [String: Any])?["items"] as? [[String: Any]] ?? []
        }
        /// "owner/repo#12" from a search result.
        func pullRef(_ item: [String: Any]) -> String? {
            guard let repoURL = item["repository_url"] as? String, let number = item["number"] as? Int else { return nil }
            let parts = repoURL.split(separator: "/").suffix(2).joined(separator: "/")
            return "\(parts)#\(number)"
        }

        let mine = await search("is:pr is:open author:\(login) archived:false")
        let asked = await search("is:pr is:open review-requested:\(login) archived:false")

        let mineItems = mine.compactMap { item -> DetailItem? in
            guard let ref = pullRef(item) else { return nil }
            let draft = item["draft"] as? Bool ?? false
            return DetailItem(title: item["title"] as? String ?? "Pull request", subtitle: ref,
                              tone: draft ? .idle : .info, date: date(item["updated_at"]),
                              url: item["html_url"] as? String, badge: draft ? "Draft" : nil,
                              actions: draft ? [] : [ServiceActionDef(kind: "github.merge", title: "Squash and merge",
                                                                      symbol: "arrow.triangle.merge", target: ref,
                                                                      confirm: "Merge \(ref) into its base branch?")])
        }
        let askedItems = asked.compactMap { item -> DetailItem? in
            guard let ref = pullRef(item) else { return nil }
            let author = (item["user"] as? [String: Any])?["login"] as? String ?? ""
            return DetailItem(title: item["title"] as? String ?? "Pull request",
                              subtitle: author.isEmpty ? ref : "\(ref) · \(author)", tone: .warning,
                              date: date(item["updated_at"]), url: item["html_url"] as? String,
                              actions: [ServiceActionDef(kind: "github.approve", title: "Approve", symbol: "checkmark.seal",
                                                         target: ref)])
        }

        // CI on the repos you pushed to last.
        let reposJSON = try? await request("https://api.github.com/user/repos?sort=pushed&per_page=5&affiliation=owner,collaborator",
                                           headers: headers)
        let repos = (reposJSON as? [[String: Any]] ?? []).compactMap { $0["full_name"] as? String }
        var runItems: [DetailItem] = []
        var failing = 0
        for repo in repos {
            let runsJSON = try? await request("https://api.github.com/repos/\(repo)/actions/runs?per_page=3", headers: headers)
            let runs = (runsJSON as? [String: Any])?["workflow_runs"] as? [[String: Any]] ?? []
            for run in runs {
                guard let id = run["id"] as? Int else { continue }
                let status = run["status"] as? String ?? ""
                let conclusion = run["conclusion"] as? String ?? ""
                var tone: ServiceTone = .idle
                var actions: [ServiceActionDef] = []
                if status != "completed" {
                    tone = .warning
                } else if conclusion == "success" {
                    tone = .ok
                } else if conclusion == "failure" || conclusion == "timed_out" {
                    tone = .error
                    failing += 1
                    actions.append(ServiceActionDef(kind: "github.rerun", title: "Re-run failed jobs",
                                                    symbol: "arrow.clockwise", target: "\(repo)/\(id)"))
                }
                let label = status == "completed" ? conclusion.replacingOccurrences(of: "_", with: " ") : status.replacingOccurrences(of: "_", with: " ")
                runItems.append(DetailItem(title: run["name"] as? String ?? "Workflow",
                                           subtitle: "\(repo) · \(run["head_branch"] as? String ?? "")",
                                           tone: tone, date: date(run["created_at"]),
                                           url: run["html_url"] as? String, badge: label.capitalized, actions: actions))
            }
        }

        var sections: [DetailSection] = []
        if !askedItems.isEmpty { sections.append(DetailSection(title: "Reviews asked of you", items: askedItems)) }
        sections.append(DetailSection(title: "Your pull requests", items: mineItems,
                                      footer: mineItems.isEmpty ? "No open pull request." : nil))
        if !runItems.isEmpty { sections.append(DetailSection(title: "CI on your latest repos", items: runItems)) }
        return ServiceDetail(pillId: "integration_github",
                             stats: [DetailStat(label: "Your PRs", value: "\(mineItems.count)", tone: .info),
                                     DetailStat(label: "Reviews", value: "\(askedItems.count)", tone: askedItems.isEmpty ? .idle : .warning),
                                     DetailStat(label: "CI failing", value: "\(failing)", tone: failing > 0 ? .error : .ok)],
                             sections: sections, fetchedAt: Date())
    }

    // Stripe: balance, payments, payouts, subscriptions. Read only.
    private static func stripe() async throws -> ServiceDetail {
        let key = try secret("stripe-api-key", "Stripe")
        let headers = ["Authorization": "Bearer \(key)"]
        let balance = try await request("https://api.stripe.com/v1/balance", headers: headers) as? [String: Any] ?? [:]
        // One entry per currency in each list, in no set order: pair them by currency.
        let availableList = balance["available"] as? [[String: Any]] ?? []
        let pendingList = balance["pending"] as? [[String: Any]] ?? []
        let currency = ((availableList.first ?? pendingList.first)?["currency"] as? String ?? "eur").lowercased()
        func amount(_ list: [[String: Any]]) -> Int {
            list.first { ($0["currency"] as? String)?.lowercased() == currency }?["amount"] as? Int ?? 0
        }
        let available = amount(availableList)
        let pending = amount(pendingList)

        /// A list, or why it couldn't be read (shown instead of a made-up zero).
        func list(_ path: String) async -> ([[String: Any]], [String: Any], String?) {
            do {
                let json = try await request("https://api.stripe.com/v1/\(path)", headers: headers) as? [String: Any] ?? [:]
                return (json["data"] as? [[String: Any]] ?? [], json, nil)
            } catch {
                return ([], [:], describe(error))
            }
        }

        let (charges, _, chargesError) = await list("charges?limit=15")
        let chargeItems = charges.map { c -> DetailItem in
            let status = c["status"] as? String ?? ""
            let refunded = c["refunded"] as? Bool ?? false
            let partlyRefunded = !refunded && (c["amount_refunded"] as? Int ?? 0) > 0
            let uncaptured = !refunded && status == "succeeded" && (c["captured"] as? Bool) == false
            let who = ((c["billing_details"] as? [String: Any])?["name"] as? String)
                ?? (c["receipt_email"] as? String) ?? (c["description"] as? String) ?? ""
            let tone: ServiceTone = refunded ? .idle
                : (uncaptured || partlyRefunded) ? .warning
                : status == "succeeded" ? .ok : status == "failed" ? .error : .warning
            let badge = refunded ? "Refunded" : uncaptured ? "Uncaptured"
                : partlyRefunded ? "Partly refunded" : status.capitalized
            return DetailItem(title: money(c["amount"] as? Int ?? 0, c["currency"] as? String ?? currency),
                              subtitle: who, tone: tone, date: date(c["created"]), badge: badge)
        }
        let (payouts, _, payoutsError) = await list("payouts?limit=5")
        let payoutItems = payouts.map { p in
            DetailItem(title: money(p["amount"] as? Int ?? 0, p["currency"] as? String ?? currency),
                       subtitle: "Arrives", tone: (p["status"] as? String) == "failed" ? .error : .info,
                       date: date(p["arrival_date"]), badge: (p["status"] as? String)?.replacingOccurrences(of: "_", with: " ").capitalized)
        }

        // Active subscriptions, every page (up to 1 000).
        var subs: [[String: Any]] = []
        var moreSubs = false
        var subsError: String?
        var cursor: String?
        for _ in 0..<10 {
            let (page, json, error) = await list("subscriptions?status=active&limit=100" + (cursor.map { "&starting_after=\($0)" } ?? ""))
            if let error { subsError = error; break }
            subs += page
            moreSubs = json["has_more"] as? Bool ?? false
            guard moreSubs, let last = subs.last?["id"] as? String else { break }
            cursor = last
        }
        // Estimated monthly revenue, one total per currency. Metered and tiered
        // prices have no fixed amount per period and discounts aren't applied.
        var monthlyByCurrency: [String: Double] = [:]
        for sub in subs {
            let subCurrency = (sub["currency"] as? String)?.lowercased()
            let items = (sub["items"] as? [String: Any])?["data"] as? [[String: Any]] ?? []
            for item in items {
                let price = item["price"] as? [String: Any] ?? [:]
                let recurring = price["recurring"] as? [String: Any] ?? [:]
                if recurring["usage_type"] as? String == "metered" || price["billing_scheme"] as? String == "tiered" { continue }
                let perUnit = (price["unit_amount"] as? Int).map { Double($0) }
                    ?? Double(price["unit_amount_decimal"] as? String ?? "") ?? 0
                let unit = perUnit * Double(item["quantity"] as? Int ?? 1)
                let count = Double(recurring["interval_count"] as? Int ?? 1)
                let perMonth: Double
                switch recurring["interval"] as? String {
                case "year": perMonth = unit / (12 * count)
                case "week": perMonth = unit * 4.345 / count
                case "day": perMonth = unit * 30.4 / count
                default: perMonth = unit / count
                }
                let itemCurrency = subCurrency ?? (price["currency"] as? String)?.lowercased() ?? currency
                monthlyByCurrency[itemCurrency, default: 0] += perMonth
            }
        }
        let largest = monthlyByCurrency.max { $0.value < $1.value }
        let mrrCurrency = monthlyByCurrency[currency] != nil ? currency : (largest?.key ?? currency)
        let monthly = monthlyByCurrency[mrrCurrency] ?? 0

        var sections = [DetailSection(title: "Payments", items: chargeItems, footer: chargesError)]
        if !payoutItems.isEmpty || payoutsError != nil {
            sections.append(DetailSection(title: "Payouts", items: payoutItems, footer: payoutsError))
        }
        if let subsError { sections.append(DetailSection(title: "Subscriptions", items: [], footer: subsError)) }
        return ServiceDetail(pillId: "integration_stripe",
                             stats: [DetailStat(label: "Available", value: money(available, currency), tone: .ok),
                                     DetailStat(label: "Pending", value: money(pending, currency)),
                                     DetailStat(label: "Subscriptions",
                                                value: subsError != nil ? "—" : (moreSubs ? "\(subs.count)+" : "\(subs.count)"),
                                                tone: .info),
                                     DetailStat(label: "Est. MRR",
                                                value: subsError != nil ? "—" : money(Int(monthly.rounded()), mrrCurrency),
                                                tone: .info)],
                             sections: sections, fetchedAt: Date())
    }

    // Resend: the latest emails and how they went, and the domains. Read only.
    private static func resend() async throws -> ServiceDetail {
        let key = try secret("resend-api-key", "Resend")
        let headers = ["Authorization": "Bearer \(key)"]
        let emailsJSON = try await request("https://api.resend.com/emails?limit=20", headers: headers)
        let emails = (emailsJSON as? [String: Any])?["data"] as? [[String: Any]] ?? []
        var bounced = 0, delivered = 0
        let emailItems = emails.map { e -> DetailItem in
            let event = e["last_event"] as? String ?? "sent"
            let tone: ServiceTone
            switch event {
            case "delivered", "opened", "clicked": tone = .ok; delivered += 1
            case "bounced", "complained", "failed", "suppressed": tone = .error; bounced += 1
            case "delivery_delayed": tone = .warning
            default: tone = .info
            }
            let to = (e["to"] as? [String])?.joined(separator: ", ") ?? ""
            return DetailItem(title: e["subject"] as? String ?? "(no subject)", subtitle: to, tone: tone,
                              date: date(e["created_at"]), badge: event.replacingOccurrences(of: "_", with: " ").capitalized)
        }
        let domainsJSON = try? await request("https://api.resend.com/domains", headers: headers)
        let domains = (domainsJSON as? [String: Any])?["data"] as? [[String: Any]] ?? []
        let domainItems = domains.map { d in
            let status = d["status"] as? String ?? ""
            return DetailItem(title: d["name"] as? String ?? "Domain", subtitle: d["region"] as? String ?? "",
                              tone: status == "verified" ? .ok : (status == "failed" ? .error : .warning),
                              badge: status.replacingOccurrences(of: "_", with: " ").capitalized)
        }
        var sections = [DetailSection(title: "Latest emails", items: emailItems)]
        if !domainItems.isEmpty { sections.append(DetailSection(title: "Domains", items: domainItems)) }
        return ServiceDetail(pillId: "integration_resend",
                             stats: [DetailStat(label: "Delivered", value: "\(delivered)", tone: .ok),
                                     DetailStat(label: "Bounced", value: "\(bounced)", tone: bounced > 0 ? .error : .idle),
                                     DetailStat(label: "Domains", value: "\(domains.count)")],
                             sections: sections, fetchedAt: Date())
    }

    // Cal.com: upcoming bookings. Read only: cancelling emails the guest and can refund or charge them.
    private static func calcom() async throws -> ServiceDetail {
        let key = try secret("calcom-api-key", "Cal.com")
        let headers = ["Authorization": "Bearer \(key)", "cal-api-version": "2024-08-13"]
        let iso = ISO8601DateFormatter()
        let now = Date()
        var components = URLComponents(string: "https://api.cal.com/v2/bookings")!
        components.queryItems = [URLQueryItem(name: "status", value: "upcoming"),
                                 URLQueryItem(name: "afterStart", value: iso.string(from: now)),
                                 URLQueryItem(name: "take", value: "30")]
        let json = try await request(components.url!.absoluteString, headers: headers)
        let bookings = (json as? [String: Any])?["data"] as? [[String: Any]] ?? []
        let calendar = Calendar.current
        var today = 0, week = 0
        let items = bookings.compactMap { b -> DetailItem? in
            guard let start = date(b["start"] ?? b["startTime"]) else { return nil }
            if calendar.isDateInToday(start) { today += 1 }
            if start.timeIntervalSince(now) < 7 * 24 * 3600 { week += 1 }
            let attendee = (b["attendees"] as? [[String: Any]])?.first
            let who = attendee?["name"] as? String ?? attendee?["email"] as? String ?? ""
            let when = start.formatted(.dateTime.weekday(.abbreviated).day().month(.abbreviated).hour().minute())
            return DetailItem(title: b["title"] as? String ?? "Meeting",
                              subtitle: who.isEmpty ? when : "\(when) · \(who)",
                              tone: calendar.isDateInToday(start) ? .warning : .info,
                              date: start, url: (b["meetingUrl"] as? String) ?? (b["location"] as? String).flatMap { $0.hasPrefix("https://") ? $0 : nil },
                              badge: (b["status"] as? String)?.capitalized)
        }
        return ServiceDetail(pillId: "integration_calcom",
                             stats: [DetailStat(label: "Today", value: "\(today)", tone: today > 0 ? .warning : .idle),
                                     DetailStat(label: "Next 7 days", value: "\(week)", tone: .info),
                                     DetailStat(label: "Upcoming", value: "\(items.count)")],
                             sections: [DetailSection(title: "Upcoming bookings", items: items,
                                                      footer: items.isEmpty ? "Nothing booked." : nil)],
                             fetchedAt: Date())
    }

    // n8n: workflows (activate, deactivate) and executions (retry a failed one).
    private static func n8n() async throws -> ServiceDetail {
        let key = try secret("n8n-api-key", "n8n")
        let base = try secret("n8n-url", "n8n").trimmingCharacters(in: CharacterSet(charactersIn: "/"))
        let headers = ["X-N8N-API-KEY": key, "Accept": "application/json"]
        // The list comes in pages (at most 250, then `cursor` = the previous `nextCursor`): read
        // them all so the counts are right.
        var workflows: [[String: Any]] = []
        var cursor: String?
        repeat {
            var url = "\(base)/api/v1/workflows?limit=250"
            if let cursor, let encoded = cursor.addingPercentEncoding(withAllowedCharacters: .alphanumerics) {
                url += "&cursor=\(encoded)"
            }
            let page = try await request(url, headers: headers) as? [String: Any]
            workflows += page?["data"] as? [[String: Any]] ?? []
            cursor = page?["nextCursor"] as? String
        } while !(cursor ?? "").isEmpty && workflows.count < 5_000
        var names: [String: String] = [:]
        var active = 0
        let workflowItems = workflows.compactMap { w -> DetailItem? in
            guard let id = (w["id"] as? String) ?? (w["id"] as? Int).map(String.init) else { return nil }
            let name = w["name"] as? String ?? "Workflow"
            names[id] = name
            // Archived workflows are listed but can't be turned on (n8n answers 400).
            if w["isArchived"] as? Bool ?? false { return nil }
            let isActive = w["active"] as? Bool ?? false
            if isActive { active += 1 }
            return DetailItem(title: name, tone: isActive ? .ok : .idle, date: date(w["updatedAt"]),
                              url: "\(base)/workflow/\(id)", badge: isActive ? "Active" : "Off",
                              actions: [isActive
                                        ? ServiceActionDef(kind: "n8n.deactivate", title: "Turn off", symbol: "pause.circle",
                                                           target: id, destructive: true, confirm: "Stop \(name) from running?")
                                        : ServiceActionDef(kind: "n8n.activate", title: "Turn on", symbol: "play.circle", target: id)])
        }
        let executionsJSON = try? await request("\(base)/api/v1/executions?limit=15", headers: headers)
        let executions = (executionsJSON as? [String: Any])?["data"] as? [[String: Any]] ?? []
        var failed = 0
        let executionItems = executions.compactMap { e -> DetailItem? in
            guard let id = (e["id"] as? String) ?? (e["id"] as? Int).map(String.init) else { return nil }
            let workflowId = (e["workflowId"] as? String) ?? (e["workflowId"] as? Int).map(String.init) ?? ""
            let status = e["status"] as? String ?? ((e["finished"] as? Bool ?? false) ? "success" : "error")
            let isFailure = status == "error" || status == "crashed" || status == "failed"
            if isFailure { failed += 1 }
            return DetailItem(title: names[workflowId] ?? "Workflow \(workflowId)", subtitle: "Execution \(id)",
                              tone: isFailure ? .error : (status == "success" ? .ok : .warning),
                              date: date(e["startedAt"]), url: "\(base)/workflow/\(workflowId)/executions/\(id)",
                              badge: status.capitalized,
                              actions: isFailure ? [ServiceActionDef(kind: "n8n.retry", title: "Retry", symbol: "arrow.clockwise", target: id)] : [])
        }
        return ServiceDetail(pillId: "integration_n8n",
                             stats: [DetailStat(label: "Workflows", value: "\(workflowItems.count)"),
                                     DetailStat(label: "Active", value: "\(active)", tone: .ok),
                                     DetailStat(label: "Failed runs", value: "\(failed)", tone: failed > 0 ? .error : .idle)],
                             sections: [DetailSection(title: "Latest runs", items: executionItems),
                                        DetailSection(title: "Workflows",
                                                      items: Array(workflowItems.sorted { ($0.date ?? .distantPast) > ($1.date ?? .distantPast) }.prefix(50)))],
                             fetchedAt: Date())
    }

    // Notion: the pages and databases edited last. Read only.
    private static func notion() async throws -> ServiceDetail {
        let key = try secret("notion-api-key", "Notion")
        let headers = ["Authorization": "Bearer \(key)", "Notion-Version": "2022-06-28"]
        let json = try await request("https://api.notion.com/v1/search", method: "POST", headers: headers,
                                     body: ["sort": ["direction": "descending", "timestamp": "last_edited_time"], "page_size": 25])
        let results = (json as? [String: Any])?["results"] as? [[String: Any]] ?? []
        var pages: [DetailItem] = []
        var databases: [DetailItem] = []
        for object in results {
            let kind = object["object"] as? String ?? "page"
            var title = ""
            if kind == "database" {
                title = ((object["title"] as? [[String: Any]])?.compactMap { $0["plain_text"] as? String }.joined()) ?? ""
            } else if let properties = object["properties"] as? [String: Any] {
                for case let property as [String: Any] in properties.values where property["type"] as? String == "title" {
                    title = ((property["title"] as? [[String: Any]])?.compactMap { $0["plain_text"] as? String }.joined()) ?? ""
                }
            }
            var emoji = ""
            if let icon = object["icon"] as? [String: Any], icon["type"] as? String == "emoji" { emoji = (icon["emoji"] as? String ?? "") + " " }
            let item = DetailItem(title: emoji + (title.isEmpty ? "Untitled" : title),
                                  date: date(object["last_edited_time"]), url: object["url"] as? String,
                                  badge: (object["archived"] as? Bool ?? false) ? "Archived" : nil)
            if kind == "database" { databases.append(item) } else { pages.append(item) }
        }
        var sections = [DetailSection(title: "Edited lately", items: pages)]
        if !databases.isEmpty { sections.append(DetailSection(title: "Databases", items: databases)) }
        let editedToday = results.filter { date($0["last_edited_time"]).map(Calendar.current.isDateInToday) ?? false }.count
        return ServiceDetail(pillId: "integration_notion",
                             stats: [DetailStat(label: "Edited today", value: "\(editedToday)", tone: editedToday > 0 ? .info : .idle),
                                     DetailStat(label: "Pages", value: "\(pages.count)"),
                                     DetailStat(label: "Databases", value: "\(databases.count)")],
                             sections: sections, fetchedAt: Date())
    }

    // MARK: Acting

    /// Runs one action. Returns a short line for the iPhone.
    static func perform(kind: String, target: String) async throws -> String {
        switch kind {
        case "vercel.redeploy":
            let parts = target.split(separator: "|", omittingEmptySubsequences: false).map(String.init)
            guard parts.count == 3 else { throw Failure(status: 0, message: "Unknown deployment") }
            var body: [String: Any] = ["name": parts[1], "deploymentId": parts[0]]
            if !parts[2].isEmpty { body["target"] = parts[2] }
            let json = try await request("https://api.vercel.com/v13/deployments", method: "POST",
                                         headers: try vercelHeaders(), body: body)
            let url = (json as? [String: Any])?["url"] as? String
            return url.map { "Building \($0)" } ?? "New deployment started"
        case "vercel.promote":
            // Vercel only promotes production builds in place: a preview is rebuilt for
            // production, as `vercel promote` does.
            let parts = target.split(separator: "|", omittingEmptySubsequences: false).map(String.init)
            guard parts.count == 2 else { throw Failure(status: 0, message: "Unknown deployment") }
            let json = try await request("https://api.vercel.com/v13/deployments", method: "POST",
                                         headers: try vercelHeaders(),
                                         body: ["deploymentId": parts[0], "name": parts[1], "target": "production",
                                                "meta": ["action": "promote"]])
            let url = (json as? [String: Any])?["url"] as? String
            return url.map { "Building \($0) for production" } ?? "Production build started"
        case "vercel.cancel":
            _ = try await request("https://api.vercel.com/v12/deployments/\(target)/cancel", method: "PATCH",
                                  headers: try vercelHeaders())
            return "Build canceled"
        case "github.rerun":
            // "owner/repo/123"
            let parts = target.split(separator: "/").map(String.init)
            guard parts.count == 3 else { throw Failure(status: 0, message: "Unknown run") }
            _ = try await request("https://api.github.com/repos/\(parts[0])/\(parts[1])/actions/runs/\(parts[2])/rerun-failed-jobs",
                                  method: "POST", headers: try githubHeaders())
            return "Failed jobs started again"
        case "github.approve", "github.merge":
            // "owner/repo#12"
            let pieces = target.split(separator: "#").map(String.init)
            guard pieces.count == 2 else { throw Failure(status: 0, message: "Unknown pull request") }
            if kind == "github.approve" {
                _ = try await request("https://api.github.com/repos/\(pieces[0])/pulls/\(pieces[1])/reviews", method: "POST",
                                      headers: try githubHeaders(), body: ["event": "APPROVE"])
                return "Approved"
            }
            _ = try await request("https://api.github.com/repos/\(pieces[0])/pulls/\(pieces[1])/merge", method: "PUT",
                                  headers: try githubHeaders(), body: ["merge_method": "squash"])
            return "Merged"
        case "n8n.activate", "n8n.deactivate", "n8n.retry":
            let key = try secret("n8n-api-key", "n8n")
            let base = try secret("n8n-url", "n8n").trimmingCharacters(in: CharacterSet(charactersIn: "/"))
            let headers = ["X-N8N-API-KEY": key, "Accept": "application/json"]
            switch kind {
            case "n8n.activate":
                _ = try await request("\(base)/api/v1/workflows/\(target)/activate", method: "POST", headers: headers)
                return "Turned on"
            case "n8n.deactivate":
                _ = try await request("\(base)/api/v1/workflows/\(target)/deactivate", method: "POST", headers: headers)
                return "Turned off"
            default:
                do {
                    _ = try await request("\(base)/api/v1/executions/\(target)/retry", method: "POST", headers: headers)
                } catch let failure as Failure where failure.status == 404 || failure.status == 405 {
                    // POST /api/v1/executions/{id}/retry only exists from n8n 1.112.0.
                    throw Failure(status: 0, message: "Couldn't retry this run. It may have been deleted, or your n8n is older than 1.112, which is needed to retry from the iPhone.")
                }
                return "Running again"
            }
        default:
            throw Failure(status: 0, message: "This action isn't available")
        }
    }

    private static func vercelHeaders() throws -> [String: String] {
        let token = try secret("vercel-token", "Vercel")
        return ["Authorization": "Bearer \(token)", "Accept": "application/json"]
    }

    private static func githubHeaders() throws -> [String: String] {
        let token = try secret("github-token", "GitHub")
        return ["Authorization": "Bearer \(token)", "Accept": "application/vnd.github+json",
                "X-GitHub-Api-Version": "2022-11-28"]
    }
}
#endif