@l22-io/orchard-mcp 0.3.1 → 0.6.0

package/swift/Sources/AppleBridge/Calendar.swift

@@ -0,0 +1,221 @@
+import EventKit
+import Foundation
+
+// Reason: All calendar access goes through EventKit, which properly handles
+// recurring event expansion via predicateForEvents -- something AppleScript cannot do.
+
+enum CalendarBridge {
+    private static let store = EKEventStore()
+
+    /// Request full calendar access. Returns true if granted.
+    static func requestAccess() async -> Bool {
+        do {
+            return try await store.requestFullAccessToEvents()
+        } catch {
+            return false
+        }
+    }
+
+    /// Check current authorization status without prompting.
+    static func authorizationStatus() -> EKAuthorizationStatus {
+        return EKEventStore.authorizationStatus(for: .event)
+    }
+
+    /// List all calendars with account and metadata.
+    static func listCalendars() async {
+        guard await requestAccess() else {
+            JSONOutput.error("Calendar access denied. Grant access in System Settings > Privacy & Security > Calendars.")
+            return
+        }
+
+        let calendars = store.calendars(for: .event)
+        let result: [[String: Any]] = calendars.map { cal in
+            var dict: [String: Any] = [
+                "id": cal.calendarIdentifier,
+                "title": cal.title,
+                "type": calendarTypeName(cal.type),
+                "allowsModify": cal.allowsContentModifications
+            ]
+            if let source = cal.source {
+                dict["account"] = source.title
+                dict["accountType"] = sourceTypeName(source.sourceType)
+            }
+            if let color = cal.cgColor {
+                // Reason: Convert CGColor to hex for easy display/filtering.
+                let components = color.components ?? []
+                if components.count >= 3 {
+                    let r = Int(components[0] * 255)
+                    let g = Int(components[1] * 255)
+                    let b = Int(components[2] * 255)
+                    dict["color"] = String(format: "#%02x%02x%02x", r, g, b)
+                }
+            }
+            return dict
+        }
+
+        JSONOutput.success(result)
+    }
+
+    /// Fetch events in a date range, optionally filtered by calendar ID.
+    /// Recurring events are properly expanded via predicateForEvents.
+    static func listEvents(startISO: String, endISO: String, calendarID: String?) async {
+        guard await requestAccess() else {
+            JSONOutput.error("Calendar access denied.")
+            return
+        }
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+        guard let startDate = formatter.date(from: startISO) ?? parseFlexibleISO(startISO) else {
+            JSONOutput.error("Invalid start date: \(startISO). Use ISO 8601 format.")
+            return
+        }
+        guard let endDate = formatter.date(from: endISO) ?? parseFlexibleISO(endISO) else {
+            JSONOutput.error("Invalid end date: \(endISO). Use ISO 8601 format.")
+            return
+        }
+
+        var calendars: [EKCalendar]? = nil
+        if let calID = calendarID {
+            if let cal = store.calendar(withIdentifier: calID) {
+                calendars = [cal]
+            } else {
+                JSONOutput.error("Calendar not found: \(calID)")
+                return
+            }
+        }
+
+        let predicate = store.predicateForEvents(withStart: startDate, end: endDate, calendars: calendars)
+        let events = store.events(matching: predicate)
+
+        let result: [[String: Any]] = events.map { evt in
+            var dict: [String: Any] = [
+                "id": evt.eventIdentifier ?? "",
+                "title": evt.title ?? "(no title)",
+                "start": iso8601(evt.startDate),
+                "end": iso8601(evt.endDate),
+                "isAllDay": evt.isAllDay,
+                "calendar": evt.calendar.title,
+                "calendarId": evt.calendar.calendarIdentifier
+            ]
+            if let location = evt.location, !location.isEmpty {
+                dict["location"] = location
+            }
+            if let notes = evt.notes, !notes.isEmpty {
+                dict["notes"] = notes
+            }
+            if let url = evt.url {
+                dict["url"] = url.absoluteString
+            }
+            if evt.hasRecurrenceRules {
+                dict["isRecurring"] = true
+            }
+            if let attendees = evt.attendees, !attendees.isEmpty {
+                dict["attendees"] = attendees.map { a in
+                    var info: [String: Any] = [
+                        "name": a.name ?? a.url.absoluteString,
+                        "status": participantStatusName(a.participantStatus)
+                    ]
+                    if a.isCurrentUser {
+                        info["isMe"] = true
+                    }
+                    return info
+                }
+            }
+            return dict
+        }
+
+        JSONOutput.success(result)
+    }
+
+    /// Search events by title within a date range.
+    static func searchEvents(query: String, startISO: String, endISO: String) async {
+        guard await requestAccess() else {
+            JSONOutput.error("Calendar access denied.")
+            return
+        }
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+        guard let startDate = formatter.date(from: startISO) ?? parseFlexibleISO(startISO) else {
+            JSONOutput.error("Invalid start date: \(startISO)")
+            return
+        }
+        guard let endDate = formatter.date(from: endISO) ?? parseFlexibleISO(endISO) else {
+            JSONOutput.error("Invalid end date: \(endISO)")
+            return
+        }
+
+        let predicate = store.predicateForEvents(withStart: startDate, end: endDate, calendars: nil)
+        let events = store.events(matching: predicate)
+
+        let lowered = query.lowercased()
+        let filtered = events.filter { evt in
+            let title = (evt.title ?? "").lowercased()
+            let notes = (evt.notes ?? "").lowercased()
+            let location = (evt.location ?? "").lowercased()
+            return title.contains(lowered) || notes.contains(lowered) || location.contains(lowered)
+        }
+
+        let result: [[String: Any]] = filtered.map { evt in
+            [
+                "id": evt.eventIdentifier ?? "",
+                "title": evt.title ?? "(no title)",
+                "start": iso8601(evt.startDate),
+                "end": iso8601(evt.endDate),
+                "isAllDay": evt.isAllDay,
+                "calendar": evt.calendar.title
+            ]
+        }
+
+        JSONOutput.success(result)
+    }
+
+    // MARK: - Helpers
+
+    private static func parseFlexibleISO(_ str: String) -> Date? {
+        // Reason: Accept date-only strings like "2026-02-17" without time component.
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withFullDate]
+        return formatter.date(from: str)
+    }
+
+    private static func calendarTypeName(_ type: EKCalendarType) -> String {
+        switch type {
+        case .local: return "local"
+        case .calDAV: return "caldav"
+        case .exchange: return "exchange"
+        case .subscription: return "subscription"
+        case .birthday: return "birthday"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private static func sourceTypeName(_ type: EKSourceType) -> String {
+        switch type {
+        case .local: return "local"
+        case .exchange: return "exchange"
+        case .calDAV: return "caldav"
+        case .mobileMe: return "mobileme"
+        case .subscribed: return "subscribed"
+        case .birthdays: return "birthdays"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private static func participantStatusName(_ status: EKParticipantStatus) -> String {
+        switch status {
+        case .unknown: return "unknown"
+        case .pending: return "pending"
+        case .accepted: return "accepted"
+        case .declined: return "declined"
+        case .tentative: return "tentative"
+        case .delegated: return "delegated"
+        case .completed: return "completed"
+        case .inProcess: return "in_process"
+        @unknown default: return "unknown"
+        }
+    }
+}

package/swift/Sources/AppleBridge/Contacts.swift

@@ -0,0 +1,225 @@
+import Contacts
+import Foundation
+
+enum ContactsBridge {
+    private static let store = CNContactStore()
+
+    static func requestAccess() async -> Bool {
+        await withCheckedContinuation { cont in
+            store.requestAccess(for: .contacts) { granted, _ in
+                cont.resume(returning: granted)
+            }
+        }
+    }
+
+    static func authorizationStatus() -> CNAuthorizationStatus {
+        CNContactStore.authorizationStatus(for: .contacts)
+    }
+
+    // MARK: - Keys
+
+    // Reason: CNContactNoteKey requires a restricted entitlement since macOS 11
+    // and is deliberately omitted here — requesting it would fail the fetch.
+    private static var defaultKeys: [CNKeyDescriptor] {
+        let stringKeys: [CNKeyDescriptor] = [
+            CNContactIdentifierKey,
+            CNContactGivenNameKey,
+            CNContactFamilyNameKey,
+            CNContactMiddleNameKey,
+            CNContactNicknameKey,
+            CNContactOrganizationNameKey,
+            CNContactJobTitleKey,
+            CNContactEmailAddressesKey,
+            CNContactPhoneNumbersKey,
+            CNContactPostalAddressesKey,
+            CNContactBirthdayKey,
+            CNContactUrlAddressesKey,
+            CNContactImageDataAvailableKey
+        ].map { $0 as CNKeyDescriptor }
+        return stringKeys + [
+            CNContactFormatter.descriptorForRequiredKeys(for: .fullName)
+        ]
+    }
+
+    // MARK: - Public API
+
+    static func listGroups() async {
+        guard await requestAccess() else {
+            JSONOutput.error("Contacts access denied. Grant access in System Settings > Privacy & Security > Contacts.")
+            return
+        }
+        do {
+            let groups = try store.groups(matching: nil)
+            let result: [[String: Any]] = try groups.map { g in
+                let predicate = CNContact.predicateForContactsInGroup(withIdentifier: g.identifier)
+                let members = try store.unifiedContacts(
+                    matching: predicate,
+                    keysToFetch: [CNContactIdentifierKey as CNKeyDescriptor]
+                )
+                return [
+                    "id": g.identifier,
+                    "name": g.name,
+                    "memberCount": members.count
+                ]
+            }
+            JSONOutput.success(result)
+        } catch {
+            JSONOutput.error("Failed to list groups: \(error.localizedDescription)")
+        }
+    }
+
+    static func search(query: String, limit: Int) async {
+        guard await requestAccess() else {
+            JSONOutput.error("Contacts access denied. Grant access in System Settings > Privacy & Security > Contacts.")
+            return
+        }
+        let results = findMatches(query: query)
+        let trimmed = Array(results.prefix(limit))
+        let summaries = trimmed.map { summary(for: $0) }
+        JSONOutput.success([
+            "contacts": summaries,
+            "total": results.count,
+            "limit": limit,
+            "hasMore": results.count > trimmed.count
+        ] as [String: Any])
+    }
+
+    static func readContact(id: String) async {
+        guard await requestAccess() else {
+            JSONOutput.error("Contacts access denied. Grant access in System Settings > Privacy & Security > Contacts.")
+            return
+        }
+        do {
+            let contact = try store.unifiedContact(
+                withIdentifier: id,
+                keysToFetch: defaultKeys
+            )
+            JSONOutput.success(fullDetail(for: contact))
+        } catch {
+            JSONOutput.error("Contact not found: \(id)")
+        }
+    }
+
+    // MARK: - Search
+
+    // Runs name / email / phone predicates, then falls back to a digits-only
+    // substring scan over every contact's phone numbers when the query looks
+    // phone-ish (CNContact.predicateForContacts(matching: CNPhoneNumber) only
+    // matches normalized full numbers — partials like "+4917" would otherwise
+    // return empty). Deduplicated by identifier.
+    private static func findMatches(query: String) -> [CNContact] {
+        var seen = Set<String>()
+        var results: [CNContact] = []
+        for predicate in predicates(for: query) {
+            do {
+                let batch = try store.unifiedContacts(matching: predicate, keysToFetch: defaultKeys)
+                for c in batch where !seen.contains(c.identifier) {
+                    seen.insert(c.identifier)
+                    results.append(c)
+                }
+            } catch {
+                continue
+            }
+        }
+        if looksLikePhone(query) {
+            for c in phoneSubstringMatches(query: query) where !seen.contains(c.identifier) {
+                seen.insert(c.identifier)
+                results.append(c)
+            }
+        }
+        return results
+    }
+
+    private static func predicates(for query: String) -> [NSPredicate] {
+        var list: [NSPredicate] = [CNContact.predicateForContacts(matchingName: query)]
+        if query.contains("@") {
+            list.append(CNContact.predicateForContacts(matchingEmailAddress: query))
+        }
+        if looksLikePhone(query) {
+            list.append(CNContact.predicateForContacts(matching: CNPhoneNumber(stringValue: query)))
+        }
+        return list
+    }
+
+    private static func looksLikePhone(_ query: String) -> Bool {
+        query.first.map { "+0123456789".contains($0) } ?? false
+    }
+
+    private static func phoneSubstringMatches(query: String) -> [CNContact] {
+        // Normalize to digits only, then also strip any leading zeros so that
+        // national-format queries (e.g. trunk-prefixed local numbers) match
+        // international-format stored phone numbers that omit the trunk digit.
+        let digits = query.filter(\.isNumber)
+        let trimmed = String(digits.drop(while: { $0 == "0" }))
+        let candidates = Set([digits, trimmed].filter { $0.count >= 3 })
+        guard !candidates.isEmpty else { return [] }
+
+        let request = CNContactFetchRequest(keysToFetch: defaultKeys)
+        request.unifyResults = true
+        var results: [CNContact] = []
+        do {
+            try store.enumerateContacts(with: request) { contact, _ in
+                for phone in contact.phoneNumbers {
+                    let phoneDigits = phone.value.stringValue.filter(\.isNumber)
+                    if candidates.contains(where: { phoneDigits.contains($0) }) {
+                        results.append(contact)
+                        return
+                    }
+                }
+            }
+        } catch {
+            return results
+        }
+        return results
+    }
+
+    // MARK: - Shaping
+
+    private static func summary(for c: CNContact) -> [String: Any] {
+        [
+            "id": c.identifier,
+            "name": CNContactFormatter.string(from: c, style: .fullName) ?? "",
+            "organization": c.organizationName,
+            "emails": c.emailAddresses.map { $0.value as String },
+            "phones": c.phoneNumbers.map { $0.value.stringValue }
+        ]
+    }
+
+    private static func fullDetail(for c: CNContact) -> [String: Any] {
+        var dict = summary(for: c)
+        dict["givenName"] = c.givenName
+        dict["middleName"] = c.middleName
+        dict["familyName"] = c.familyName
+        dict["nickname"] = c.nickname
+        dict["jobTitle"] = c.jobTitle
+        dict["emails"] = c.emailAddresses.map { labeled($0.label, $0.value as String) }
+        dict["phones"] = c.phoneNumbers.map { labeled($0.label, $0.value.stringValue) }
+        dict["addresses"] = c.postalAddresses.map { postalDict($0) }
+        dict["urls"] = c.urlAddresses.map { labeled($0.label, $0.value as String) }
+        if let bday = c.birthday, let date = Calendar(identifier: .gregorian).date(from: bday) {
+            dict["birthday"] = ISO8601DateFormatter().string(from: date)
+        }
+        dict["hasImage"] = c.imageDataAvailable
+        return dict
+    }
+
+    private static func labeled(_ label: String?, _ value: String) -> [String: Any] {
+        var d: [String: Any] = ["value": value]
+        if let l = label {
+            d["label"] = CNLabeledValue<NSString>.localizedString(forLabel: l)
+        }
+        return d
+    }
+
+    private static func postalDict(_ entry: CNLabeledValue<CNPostalAddress>) -> [String: Any] {
+        let a = entry.value
+        return [
+            "label": entry.label.map { CNLabeledValue<NSString>.localizedString(forLabel: $0) } ?? "",
+            "street": a.street,
+            "city": a.city,
+            "state": a.state,
+            "postalCode": a.postalCode,
+            "country": a.country
+        ]
+    }
+}

package/swift/Sources/AppleBridge/Doctor.swift

@@ -0,0 +1,252 @@
+import Contacts
+import EventKit
+import Foundation
+
+// Reason: The doctor subcommand provides a single entry point to verify
+// all permissions are granted and list accessible resources. Useful for
+// first-run setup and debugging.
+
+enum DoctorBridge {
+    static func run() async {
+        var report: [String: Any] = [
+            "version": "0.5.0",
+            "platform": "macOS",
+            "systemVersion": ProcessInfo.processInfo.operatingSystemVersionString
+        ]
+
+        // Calendar permissions
+        let calStatus = EKEventStore.authorizationStatus(for: .event)
+        let calStatusStr = authStatusName(calStatus)
+        report["calendar"] = [
+            "status": calStatusStr,
+            "granted": calStatus == .fullAccess
+        ]
+
+        // Reason: If not determined, attempt to request so the user gets prompted.
+        if calStatus == .notDetermined {
+            let granted = await CalendarBridge.requestAccess()
+            report["calendar"] = [
+                "status": granted ? "fullAccess" : "denied",
+                "granted": granted,
+                "note": "Permission was just requested."
+            ]
+        }
+
+        // If we have calendar access, list calendar count and accounts
+        if calStatus == .fullAccess || calStatus == .notDetermined {
+            let store = EKEventStore()
+            _ = try? await store.requestFullAccessToEvents()
+            let calendars = store.calendars(for: .event)
+            let accounts = Set(calendars.compactMap { $0.source?.title })
+            report["calendarSummary"] = [
+                "count": calendars.count,
+                "accounts": Array(accounts).sorted()
+            ]
+        }
+
+        // Reminders permissions
+        let remStatus = EKEventStore.authorizationStatus(for: .reminder)
+        report["reminders"] = [
+            "status": authStatusName(remStatus),
+            "granted": remStatus == .fullAccess
+        ]
+
+        if remStatus == .notDetermined {
+            let granted = await RemindersBridge.requestAccess()
+            report["reminders"] = [
+                "status": granted ? "fullAccess" : "denied",
+                "granted": granted,
+                "note": "Permission was just requested."
+            ]
+        }
+
+        if remStatus == .fullAccess || remStatus == .notDetermined {
+            let store = EKEventStore()
+            _ = try? await store.requestFullAccessToReminders()
+            let lists = store.calendars(for: .reminder)
+            report["remindersSummary"] = [
+                "count": lists.count,
+                "lists": lists.map { $0.title }.sorted()
+            ]
+        }
+
+        // Mail -- we can only check if osascript is available
+        // Reason: Mail access is via AppleScript, no programmatic permission check exists.
+        let mailCheck = checkMailAccess()
+        report["mail"] = mailCheck
+
+        // iWork apps
+        let numbersCheck = checkIWorkApp("Numbers")
+        let pagesCheck = checkIWorkApp("Pages")
+        let keynoteCheck = checkIWorkApp("Keynote")
+        report["numbers"] = numbersCheck
+        report["pages"] = pagesCheck
+        report["keynote"] = keynoteCheck
+
+        // Notes -- AppleScript-based, same shape as Mail
+        report["notes"] = checkNotesAccess()
+
+        // Contacts -- native CNContactStore
+        let contactsStatus = CNContactStore.authorizationStatus(for: .contacts)
+        report["contacts"] = [
+            "status": contactsAuthName(contactsStatus),
+            "granted": contactsStatus == .authorized
+        ]
+        if contactsStatus == .notDetermined {
+            let granted = await ContactsBridge.requestAccess()
+            report["contacts"] = [
+                "status": granted ? "authorized" : "denied",
+                "granted": granted,
+                "note": "Permission was just requested."
+            ]
+        }
+
+        // Guidance
+        var actions: [String] = []
+        if calStatus != .fullAccess {
+            actions.append("Calendar: Grant access in System Settings > Privacy & Security > Calendars")
+        }
+        if remStatus != .fullAccess {
+            actions.append("Reminders: Grant access in System Settings > Privacy & Security > Reminders")
+        }
+        if !(mailCheck["accessible"] as? Bool ?? false) {
+            actions.append("Mail: Run apple-bridge with a mail subcommand to trigger the Automation permission dialog")
+        }
+        if !(numbersCheck["installed"] as? Bool ?? false) {
+            actions.append("Numbers: Install from App Store for spreadsheet tools")
+        }
+        if !(pagesCheck["installed"] as? Bool ?? false) {
+            actions.append("Pages: Install from App Store for document tools")
+        }
+        if !(keynoteCheck["installed"] as? Bool ?? false) {
+            actions.append("Keynote: Install from App Store for presentation tools")
+        }
+        let notesAccessible = (report["notes"] as? [String: Any])?["accessible"] as? Bool ?? false
+        if !notesAccessible {
+            actions.append("Notes: Run apple-bridge with a notes subcommand to trigger the Automation permission dialog")
+        }
+        if contactsStatus != .authorized {
+            actions.append("Contacts: Grant access in System Settings > Privacy & Security > Contacts")
+        }
+        if !actions.isEmpty {
+            report["requiredActions"] = actions
+        }
+
+        JSONOutput.success(report)
+    }
+
+    private static func authStatusName(_ status: EKAuthorizationStatus) -> String {
+        switch status {
+        case .notDetermined: return "notDetermined"
+        case .restricted: return "restricted"
+        case .denied: return "denied"
+        case .fullAccess: return "fullAccess"
+        case .writeOnly: return "writeOnly"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private static func checkIWorkApp(_ appName: String) -> [String: Any] {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
+        task.arguments = ["-e", "tell application \"\(appName)\" to return name"]
+        let outPipe = Pipe()
+        let errPipe = Pipe()
+        task.standardOutput = outPipe
+        task.standardError = errPipe
+
+        do {
+            try task.run()
+            task.waitUntilExit()
+            if task.terminationStatus == 0 {
+                return ["installed": true, "accessible": true]
+            } else {
+                let errData = errPipe.fileHandleForReading.readDataToEndOfFile()
+                let errStr = String(data: errData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+                if errStr.contains("-600") || errStr.contains("not running") {
+                    return ["installed": true, "accessible": false, "note": "\(appName) is not running."]
+                }
+                return ["installed": false, "accessible": false, "note": "\(appName) may not be installed."]
+            }
+        } catch {
+            return ["installed": false, "accessible": false, "note": "Could not check \(appName): \(error.localizedDescription)"]
+        }
+    }
+
+    private static func contactsAuthName(_ status: CNAuthorizationStatus) -> String {
+        switch status {
+        case .notDetermined: return "notDetermined"
+        case .restricted: return "restricted"
+        case .denied: return "denied"
+        case .authorized: return "authorized"
+        case .limited: return "limited"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private static func checkNotesAccess() -> [String: Any] {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
+        task.arguments = ["-e", "tell application \"Notes\" to count of accounts"]
+        let pipe = Pipe()
+        task.standardOutput = pipe
+        task.standardError = Pipe()
+
+        do {
+            try task.run()
+            task.waitUntilExit()
+            if task.terminationStatus == 0 {
+                let data = pipe.fileHandleForReading.readDataToEndOfFile()
+                let output = String(data: data, encoding: .utf8)?
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                return [
+                    "accessible": true,
+                    "accountCount": Int(output ?? "0") ?? 0
+                ]
+            }
+            return [
+                "accessible": false,
+                "note": "Notes automation permission not yet granted or Notes.app not running."
+            ]
+        } catch {
+            return [
+                "accessible": false,
+                "note": "Could not run osascript: \(error.localizedDescription)"
+            ]
+        }
+    }
+
+    private static func checkMailAccess() -> [String: Any] {
+        // Reason: Try a minimal AppleScript to see if Mail.app is accessible.
+        // This doesn't send the permission prompt -- it just checks if we can talk to Mail.
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
+        task.arguments = ["-e", "tell application \"Mail\" to count of accounts"]
+        let pipe = Pipe()
+        task.standardOutput = pipe
+        task.standardError = Pipe()
+
+        do {
+            try task.run()
+            task.waitUntilExit()
+            if task.terminationStatus == 0 {
+                let data = pipe.fileHandleForReading.readDataToEndOfFile()
+                let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
+                return [
+                    "accessible": true,
+                    "accountCount": Int(output ?? "0") ?? 0
+                ]
+            } else {
+                return [
+                    "accessible": false,
+                    "note": "Mail automation permission not yet granted or Mail.app not running."
+                ]
+            }
+        } catch {
+            return [
+                "accessible": false,
+                "note": "Could not run osascript: \(error.localizedDescription)"
+            ]
+        }
+    }
+}