Add Google Meet desktop widget system with sidebar integration.

Ports the widget architecture to meetings_app, including floating desktop panels, persisted widget instances, and in-app widget management wired to schedule snapshots and navigation actions.

Made-with: Cursor

meetings_app/AppDelegate.swift

@@ -20,6 +20,7 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         NSApp.appearance = NSAppearance(named: darkEnabled ? .darkAqua : .aqua)
         UNUserNotificationCenter.current().delegate = self
         MeetingReminderManager.shared.requestPermissionIfNeeded()
+        DesktopWidgetWindowManager.shared.restore()
     }
 
     func applicationWillTerminate(_ aNotification: Notification) {

meetings_app/ViewController.swift

@@ -15,7 +15,8 @@ private enum SidebarPage: Int {
     case joinMeetings = 0
     case photo = 1
     case video = 2
-    case settings = 3
+    case widgets = 3
+    case settings = 4
 }
 
 private enum ZoomJoinMode: Int {
@@ -353,6 +354,7 @@ final class ViewController: NSViewController {
     private var scheduleProfileImageTask: Task<Void, Never>?
     private var googleAccountPopover: NSPopover?
     private var scheduleCachedMeetings: [ScheduledMeeting] = []
+    private let widgetSnapshotLimit: Int = 3
 
     private var schedulePageFilter: SchedulePageFilter = .all
     private var schedulePageFromDate: Date = Calendar.current.startOfDay(for: Date())
@@ -446,6 +448,7 @@ final class ViewController: NSViewController {
         migrateLegacyRatingStateIfNeeded()
         beginUsageTrackingSessionIfNeeded()
         observeAppLifecycleForUsageTrackingIfNeeded()
+        registerWidgetNotificationObservers()
         setupRootView()
         buildMainLayout()
         showLaunchSplashIfNeeded()
@@ -454,6 +457,7 @@ final class ViewController: NSViewController {
 
     override func viewDidAppear() {
         super.viewDidAppear()
+        DesktopWidgetWindowManager.shared.restore()
         hasViewAppearedOnce = true
         presentLaunchPaywallIfNeeded()
         dismissLaunchSplashIfReady()
@@ -494,9 +498,7 @@ final class ViewController: NSViewController {
         endUsageTrackingSession()
         launchSplashTimeoutWorkItem?.cancel()
         launchSplashMinimumDelayWorkItem?.cancel()
-        if hasObservedAppLifecycleForUsage {
-            NotificationCenter.default.removeObserver(self)
-        }
+        NotificationCenter.default.removeObserver(self)
         if let observer = schedulePageScrollObservation {
             NotificationCenter.default.removeObserver(observer)
         }
@@ -685,6 +687,35 @@ private extension ViewController {
         showSidebarPage(page)
     }
 
+    private func registerWidgetNotificationObservers() {
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenJoinMeetingsPageRequested), name: .widgetOpenJoinMeetingsPage, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenSchedulePageRequested), name: .widgetOpenSchedulePage, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenCalendarPageRequested), name: .widgetOpenCalendarPage, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenSettingsPageRequested), name: .widgetOpenSettingsPage, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetSignInRequested), name: .widgetSignInRequested, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetRefreshRequested), name: .widgetRefreshRequested, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenMeetWebRequested), name: .widgetOpenMeetWebRequested, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(widgetOpenMeetingLinkRequested(_:)), name: .widgetOpenMeetingLinkRequested, object: nil)
+    }
+
+    @objc private func widgetOpenJoinMeetingsPageRequested() { showSidebarPage(.joinMeetings) }
+    @objc private func widgetOpenSchedulePageRequested() { showSidebarPage(.photo) }
+    @objc private func widgetOpenCalendarPageRequested() { showSidebarPage(.video) }
+    @objc private func widgetOpenSettingsPageRequested() { showSidebarPage(.settings) }
+    @objc private func widgetSignInRequested() { scheduleConnectClicked() }
+    @objc private func widgetRefreshRequested() { scheduleReloadClicked() }
+
+    @objc private func widgetOpenMeetWebRequested() {
+        guard let url = URL(string: "https://meet.google.com/") else { return }
+        openInDefaultBrowser(url: url)
+    }
+
+    @objc private func widgetOpenMeetingLinkRequested(_ notification: Notification) {
+        guard let link = notification.userInfo?["link"] as? String,
+              let url = URL(string: link.trimmingCharacters(in: .whitespacesAndNewlines)) else { return }
+        openInDefaultBrowser(url: url)
+    }
+
     @objc private func joinMeetClicked(_ sender: Any?) {
         let rawInput = meetLinkField?.stringValue.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
 
@@ -1558,6 +1589,7 @@ private extension ViewController {
         pageCache[.joinMeetings] = nil
         pageCache[.photo] = nil
         pageCache[.video] = nil
+        pageCache[.widgets] = nil
         pageCache[.settings] = nil
         showSidebarPage(selectedSidebarPage)
     }
@@ -1817,6 +1849,8 @@ private extension ViewController {
             built = makeSchedulePageContent()
         case .video:
             built = makeCalendarPageContent()
+        case .widgets:
+            built = makeWidgetsPageContent()
         case .settings:
             built = makeSettingsPageContent()
         }
@@ -1824,6 +1858,12 @@ private extension ViewController {
         return built
     }
 
+    private func makeWidgetsPageContent() -> NSView {
+        makeWidgetsPageHost(canAddWidgets: storeKitCoordinator.hasPremiumAccess) { [weak self] in
+            self?.showPaywall()
+        }
+    }
+
     private func makePlaceholderPage(title: String, subtitle: String) -> NSView {
         let panel = NSView()
         panel.translatesAutoresizingMaskIntoConstraints = false
@@ -2308,6 +2348,8 @@ private extension ViewController {
             title = "Schedule"
         case .video:
             title = "Calendar"
+        case .widgets:
+            title = "Widgets"
         case .settings:
             title = "Settings"
         }
@@ -2330,7 +2372,7 @@ private extension ViewController {
     private func logoTemplateForSidebarPage(_ page: SidebarPage) -> Bool {
         switch page {
         case .photo: return false
-        case .joinMeetings, .video, .settings: return true
+        case .joinMeetings, .video, .widgets, .settings: return true
         }
     }
 
@@ -2389,6 +2431,9 @@ private extension ViewController {
         let videoRow = sidebarItem("Calendar", icon: "􀎚", page: .video, systemSymbolName: "calendar")
         menuStack.addArrangedSubview(videoRow)
         sidebarRowViews[.video] = videoRow
+        let widgetsRow = sidebarItem("Widgets", icon: "􀏅", page: .widgets, systemSymbolName: "square.grid.2x2.fill")
+        menuStack.addArrangedSubview(widgetsRow)
+        sidebarRowViews[.widgets] = widgetsRow
         menuStack.addArrangedSubview(sidebarSectionTitle("Additional"))
         let settingsRow = sidebarItem("Settings", icon: "􀍟", page: .settings, systemSymbolName: "gearshape.fill", logoHeightMultiplier: 1, showsDisclosure: true)
         menuStack.addArrangedSubview(settingsRow)
@@ -6725,6 +6770,8 @@ private extension ViewController {
                         renderScheduleCards(into: stack, meetings: [])
                     }
                     scheduleCachedMeetings = []
+                    publishWidgetMeetingsSnapshot(from: [])
+                    DesktopWidgetWindowManager.shared.refreshForAuthStateChange()
                     MeetingReminderManager.shared.cancelAllReminders()
                     applySchedulePageFiltersAndRender()
                     if calendarPageGridStack != nil {
@@ -6749,6 +6796,8 @@ private extension ViewController {
                     renderScheduleCards(into: stack, meetings: filtered)
                 }
                 scheduleCachedMeetings = meetings
+                publishWidgetMeetingsSnapshot(from: filtered)
+                DesktopWidgetWindowManager.shared.refreshForAuthStateChange()
                 if storeKitCoordinator.hasPremiumAccess {
                     MeetingReminderManager.shared.scheduleReminders(for: meetings)
                 }
@@ -6771,6 +6820,8 @@ private extension ViewController {
                     renderScheduleCards(into: stack, meetings: [])
                 }
                 scheduleCachedMeetings = []
+                publishWidgetMeetingsSnapshot(from: [])
+                DesktopWidgetWindowManager.shared.refreshForAuthStateChange()
                 MeetingReminderManager.shared.cancelAllReminders()
                 applySchedulePageFiltersAndRender()
                 if calendarPageGridStack != nil {
@@ -6783,6 +6834,26 @@ private extension ViewController {
         }
     }
 
+    private func publishWidgetMeetingsSnapshot(from meetings: [ScheduledMeeting]) {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "EEE, h:mm a"
+        formatter.locale = Locale.current
+        let payload = meetings.prefix(widgetSnapshotLimit).map { meeting in
+            let endText = DateFormatter.localizedString(from: meeting.endDate, dateStyle: .none, timeStyle: .short)
+            return WidgetMeetingSnapshot(
+                id: meeting.id,
+                title: meeting.title,
+                timeText: "\(formatter.string(from: meeting.startDate)) - \(endText)",
+                joinLink: meeting.meetURL.absoluteString
+            )
+        }
+        if let data = try? JSONEncoder().encode(payload) {
+            UserDefaults.standard.set(data, forKey: WidgetMeetingStore.key)
+        } else {
+            UserDefaults.standard.removeObject(forKey: WidgetMeetingStore.key)
+        }
+    }
+
     func showScheduleHelp() {
         let alert = NSAlert()
         alert.messageText = "Google schedule"
@@ -6801,6 +6872,7 @@ private extension ViewController {
                     self.scheduleDateHeadingLabel?.stringValue = "Refreshing…"
                     self.pageCache[.joinMeetings] = nil
                     self.pageCache[.photo] = nil
+                    self.pageCache[.widgets] = nil
                     self.showSidebarPage(self.selectedSidebarPage)
                 }
                 await self.loadSchedule()
@@ -6830,6 +6902,7 @@ private extension ViewController {
                     self.pageCache[.joinMeetings] = nil
                     self.pageCache[.photo] = nil
                     self.pageCache[.video] = nil
+                    self.pageCache[.widgets] = nil
                     self.pageCache[.settings] = nil
                     self.showSidebarPage(self.selectedSidebarPage)
                 }
@@ -6878,10 +6951,13 @@ private extension ViewController {
             MeetingReminderManager.shared.cancelAllReminders()
             try googleOAuth.signOut()
             applyGoogleProfile(nil)
+            publishWidgetMeetingsSnapshot(from: [])
+            DesktopWidgetWindowManager.shared.refreshForAuthStateChange()
             updateGoogleAuthButtonTitle()
             pageCache[.joinMeetings] = nil
             pageCache[.photo] = nil
             pageCache[.video] = nil
+            pageCache[.widgets] = nil
             pageCache[.settings] = nil
             showSidebarPage(selectedSidebarPage)
             Task { [weak self] in

meetings_app/Widgets/DesktopWidgetView.swift

@@ -0,0 +1,371 @@
+import SwiftUI
+import AppKit
+
+struct DesktopWidgetView: View {
+    let variant: WidgetVariant
+    var isPreview: Bool
+    private let authService = GoogleOAuthService.shared
+
+    private var isSignedIn: Bool {
+        if isPreview { return true }
+        return authService.loadTokens() != nil
+    }
+
+    private var topMeetings: [WidgetMeetingSnapshot] {
+        WidgetMeetingStore.load().prefix(3).map { $0 }
+    }
+
+    var body: some View {
+        ZStack {
+            RoundedRectangle(cornerRadius: 22, style: .continuous)
+                .fill(
+                    LinearGradient(
+                        colors: [
+                            Color(red: 0.08, green: 0.48, blue: 0.86),
+                            Color(red: 0.09, green: 0.66, blue: 0.46)
+                        ],
+                        startPoint: .topLeading,
+                        endPoint: .bottomTrailing
+                    )
+                )
+                .overlay(
+                    RoundedRectangle(cornerRadius: 22, style: .continuous)
+                        .stroke(Color.white.opacity(0.14), lineWidth: 1)
+                )
+
+            VStack(alignment: .leading, spacing: 12) {
+                widgetHeader
+                contentBody
+                if variant.size != .small {
+                    Spacer(minLength: 0)
+                }
+            }
+            .padding(.horizontal, 14)
+            .padding(.bottom, variant.size == .medium ? 30 : 14)
+            .padding(.top, variant.size == .medium ? 34 : (variant.size == .small ? 10 : 14))
+        }
+    }
+
+    @ViewBuilder
+    private var contentBody: some View {
+        if !isSignedIn {
+            loggedOutContent
+        } else {
+            switch variant.size {
+            case .small:
+                VStack(alignment: .leading, spacing: 10) {
+                    Text("Quick actions")
+                        .font(.system(size: 11.5, weight: .semibold))
+                        .foregroundStyle(.white.opacity(0.78))
+                    compactActionButton(title: "Open Meet", icon: "video.fill", destination: .openMeetWeb)
+                    HStack(spacing: 8) {
+                        compactActionButton(title: "Schedule", icon: "clock.badge.checkmark", destination: .schedule)
+                        compactActionButton(title: "Settings", icon: "gearshape.fill", destination: .settings)
+                    }
+                }
+            case .medium:
+                meetingBlock(maxRows: 2)
+                LazyVGrid(columns: Array(repeating: GridItem(.flexible(minimum: 0), spacing: 8), count: 2), spacing: 8) {
+                    ForEach(variant.quickActions.prefix(4)) { action in
+                        actionTile(action)
+                    }
+                }
+            case .large:
+                meetingBlock(maxRows: 3)
+                Divider().overlay(Color.white.opacity(0.18))
+                LazyVGrid(columns: Array(repeating: GridItem(.flexible(minimum: 0), spacing: 8), count: 2), spacing: 8) {
+                    ForEach(variant.quickActions.prefix(6)) { action in
+                        actionTile(action)
+                    }
+                }
+            }
+        }
+    }
+
+    private var widgetHeader: some View {
+        HStack(spacing: 10) {
+            Image("HeaderLogo")
+                .resizable()
+                .scaledToFit()
+                .frame(width: 30, height: 30)
+                .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
+            VStack(alignment: .leading, spacing: 2) {
+                Text(variant.title)
+                    .font(.system(size: 16, weight: .bold))
+                    .foregroundStyle(.white.opacity(0.95))
+                Text(variant.subtitle)
+                    .font(.system(size: 12, weight: .medium))
+                    .foregroundStyle(.white.opacity(0.8))
+            }
+            Spacer(minLength: 0)
+        }
+    }
+
+    private func meetingBlock(maxRows: Int) -> some View {
+        VStack(alignment: .leading, spacing: 9) {
+            Text("Upcoming meetings")
+                .font(.system(size: 11.5, weight: .semibold))
+                .foregroundStyle(.white.opacity(0.80))
+            if topMeetings.isEmpty {
+                Text("No upcoming meetings")
+                    .font(.system(size: 12, weight: .medium))
+                    .foregroundStyle(.white.opacity(0.82))
+            } else {
+                VStack(alignment: .leading, spacing: 8) {
+                    ForEach(topMeetings.prefix(maxRows)) { meeting in
+                        meetingRow(meeting)
+                    }
+                }
+            }
+        }
+    }
+
+    @ViewBuilder
+    private var loggedOutContent: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            Text("Connect Google to use widget actions.")
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(.white.opacity(0.86))
+            Button(action: { open(action: WidgetQuickAction(id: "login", title: "Login", systemImage: "person.crop.circle.badge.checkmark", destination: .signIn)) }) {
+                HStack(spacing: 8) {
+                    Image(systemName: "person.crop.circle.badge.checkmark")
+                        .font(.system(size: 12, weight: .semibold))
+                    Text("Sign in with Google")
+                        .font(.system(size: 12.5, weight: .bold))
+                    Spacer(minLength: 0)
+                }
+                .foregroundStyle(.white.opacity(0.95))
+                .padding(.horizontal, 12)
+                .padding(.vertical, 10)
+                .background(
+                    RoundedRectangle(cornerRadius: 12, style: .continuous)
+                        .fill(Color.black.opacity(0.24))
+                )
+                .overlay(
+                    RoundedRectangle(cornerRadius: 12, style: .continuous)
+                        .stroke(Color.white.opacity(0.16), lineWidth: 1)
+                )
+            }
+            .buttonStyle(.plain)
+            .disabled(isPreview)
+            .allowsHitTesting(!isPreview)
+        }
+    }
+
+    private func meetingRow(_ meeting: WidgetMeetingSnapshot) -> some View {
+        Button(action: {
+            if let link = meeting.joinLink?.trimmingCharacters(in: .whitespacesAndNewlines), !link.isEmpty {
+                WidgetAppNavigator.openMeetingLink(link)
+            } else {
+                WidgetAppNavigator.open(target: .schedule)
+            }
+        }) {
+            HStack(spacing: 8) {
+                Image(systemName: "video.fill")
+                    .font(.system(size: 11, weight: .semibold))
+                    .foregroundStyle(.white.opacity(0.88))
+                VStack(alignment: .leading, spacing: 1) {
+                    Text(meeting.title)
+                        .font(.system(size: 11.5, weight: .semibold))
+                        .foregroundStyle(.white.opacity(0.93))
+                        .lineLimit(1)
+                    Text(meeting.timeText)
+                        .font(.system(size: 10.5, weight: .medium))
+                        .foregroundStyle(.white.opacity(0.74))
+                        .lineLimit(1)
+                }
+                Spacer(minLength: 0)
+            }
+            .padding(.horizontal, 10)
+            .padding(.vertical, 7)
+            .background(
+                RoundedRectangle(cornerRadius: 10, style: .continuous)
+                    .fill(Color.black.opacity(0.20))
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: 10, style: .continuous)
+                    .stroke(Color.white.opacity(0.08), lineWidth: 1)
+            )
+        }
+        .buttonStyle(.plain)
+        .disabled(isPreview)
+        .allowsHitTesting(!isPreview)
+    }
+
+    private func compactActionButton(title: String, icon: String, destination: WidgetQuickAction.Destination) -> some View {
+        Button(action: { WidgetAppNavigator.open(target: destination) }) {
+            HStack(spacing: 5) {
+                Image(systemName: icon)
+                    .font(.system(size: 10.5, weight: .semibold))
+                    .frame(width: 14)
+                Text(title)
+                    .font(.system(size: 11.5, weight: .bold))
+                    .lineLimit(1)
+                    .minimumScaleFactor(0.82)
+                    .layoutPriority(1)
+            }
+            .foregroundStyle(.white.opacity(0.97))
+            .padding(.horizontal, 10)
+            .padding(.vertical, 8)
+            .frame(maxWidth: .infinity)
+            .background(
+                RoundedRectangle(cornerRadius: 12, style: .continuous)
+                    .fill(Color.black.opacity(0.30))
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: 12, style: .continuous)
+                    .stroke(Color.white.opacity(0.24), lineWidth: 1)
+            )
+        }
+        .buttonStyle(.plain)
+        .disabled(isPreview)
+        .allowsHitTesting(!isPreview)
+    }
+
+    private func actionTile(_ action: WidgetQuickAction) -> some View {
+        Button(action: { open(action: action) }) {
+            HStack(spacing: 8) {
+                Image(systemName: action.systemImage)
+                    .font(.system(size: 11, weight: .semibold))
+                Text(action.title)
+                    .font(.system(size: 12, weight: .bold))
+                    .lineLimit(1)
+                Spacer(minLength: 0)
+            }
+            .foregroundStyle(.white.opacity(0.92))
+            .padding(.horizontal, 10)
+            .padding(.vertical, 9)
+            .background(
+                RoundedRectangle(cornerRadius: 12, style: .continuous)
+                    .fill(Color.black.opacity(0.24))
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: 12, style: .continuous)
+                    .stroke(Color.white.opacity(0.10), lineWidth: 1)
+            )
+        }
+        .buttonStyle(.plain)
+        .disabled(isPreview)
+        .allowsHitTesting(!isPreview)
+    }
+
+    private func open(action: WidgetQuickAction) {
+        guard !isPreview else { return }
+        WidgetAppNavigator.open(target: action.destination)
+    }
+}
+
+struct WidgetMeetingSnapshot: Codable, Identifiable {
+    let id: String
+    let title: String
+    let timeText: String
+    let joinLink: String?
+}
+
+enum WidgetMeetingStore {
+    static let key = "meetings.widget.topMeetings"
+
+    static func load() -> [WidgetMeetingSnapshot] {
+        guard let data = UserDefaults.standard.data(forKey: key) else { return [] }
+        return (try? JSONDecoder().decode([WidgetMeetingSnapshot].self, from: data)) ?? []
+    }
+}
+
+enum WidgetAppNavigator {
+    static func open(target: WidgetQuickAction.Destination) {
+        DispatchQueue.main.async {
+            if target == .refreshMeetings {
+                postTarget(target, delay: 0)
+                return
+            }
+            if target == .signIn {
+                postTarget(target, delay: 0)
+                return
+            }
+
+            bringAppToFront()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.18) {
+                bringAppToFront()
+            }
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.42) {
+                bringAppToFront()
+            }
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.60) {
+                activateApplicationFallback()
+                bringAppToFront()
+            }
+            postTarget(target, delay: 0.30)
+        }
+    }
+
+    static func openMeetingLink(_ link: String) {
+        DispatchQueue.main.async {
+            bringAppToFront()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.20) {
+                bringAppToFront()
+            }
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.36) {
+                NotificationCenter.default.post(
+                    name: .widgetOpenMeetingLinkRequested,
+                    object: nil,
+                    userInfo: ["link": link]
+                )
+            }
+        }
+    }
+
+    private static func bringAppToFront() {
+        NSApp.unhide(nil)
+        NSRunningApplication.current.activate(options: [.activateAllWindows, .activateIgnoringOtherApps])
+        NSApp.activate(ignoringOtherApps: true)
+        NSApp.arrangeInFront(nil)
+        for window in NSApp.windows where window.contentViewController is ViewController {
+            if window.isMiniaturized {
+                window.deminiaturize(nil)
+            }
+            window.orderFrontRegardless()
+            window.makeKeyAndOrderFront(nil)
+        }
+    }
+
+    private static func activateApplicationFallback() {
+        let bundleID = Bundle.main.bundleIdentifier ?? "com.mqldev.meetingsapp"
+        let scriptSource = "tell application id \"\(bundleID)\" to activate"
+        if let script = NSAppleScript(source: scriptSource) {
+            var errorInfo: NSDictionary?
+            script.executeAndReturnError(&errorInfo)
+        }
+    }
+
+    private static func postTarget(_ target: WidgetQuickAction.Destination, delay: TimeInterval) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+            switch target {
+            case .joinMeetings:
+                NotificationCenter.default.post(name: .widgetOpenJoinMeetingsPage, object: nil)
+            case .schedule:
+                NotificationCenter.default.post(name: .widgetOpenSchedulePage, object: nil)
+            case .calendar:
+                NotificationCenter.default.post(name: .widgetOpenCalendarPage, object: nil)
+            case .settings:
+                NotificationCenter.default.post(name: .widgetOpenSettingsPage, object: nil)
+            case .signIn:
+                NotificationCenter.default.post(name: .widgetSignInRequested, object: nil)
+            case .openMeetWeb:
+                NotificationCenter.default.post(name: .widgetOpenMeetWebRequested, object: nil)
+            case .refreshMeetings:
+                NotificationCenter.default.post(name: .widgetRefreshRequested, object: nil)
+            }
+        }
+    }
+}
+
+extension Notification.Name {
+    static let widgetOpenJoinMeetingsPage = Notification.Name("widgetOpenJoinMeetingsPage")
+    static let widgetOpenSchedulePage = Notification.Name("widgetOpenSchedulePage")
+    static let widgetOpenCalendarPage = Notification.Name("widgetOpenCalendarPage")
+    static let widgetOpenSettingsPage = Notification.Name("widgetOpenSettingsPage")
+    static let widgetSignInRequested = Notification.Name("widgetSignInRequested")
+    static let widgetOpenMeetWebRequested = Notification.Name("widgetOpenMeetWebRequested")
+    static let widgetRefreshRequested = Notification.Name("widgetRefreshRequested")
+    static let widgetOpenMeetingLinkRequested = Notification.Name("widgetOpenMeetingLinkRequested")
+}

meetings_app/Widgets/DesktopWidgetWindowManager.swift

@@ -0,0 +1,283 @@
+import AppKit
+import SwiftUI
+import Combine
+
+final class DesktopWidgetWindowManager: ObservableObject {
+    static let shared = DesktopWidgetWindowManager()
+
+    private let storageKey = "meetings.widget.instancesData"
+    private var windowsByInstanceID: [UUID: NSPanel] = [:]
+    @Published private(set) var instancesChangeToken: Int = 0
+    @Published private(set) var authStateRefreshToken: Int = 0
+
+    private init() {}
+
+    private struct StoredWidgetMeetingSnapshot: Decodable {
+        let id: String
+    }
+
+    func hasInstance(variantID: String) -> Bool {
+        loadInstances().contains { $0.variantID == variantID }
+    }
+
+    func show(instance: WidgetInstance) {
+        let variant = WidgetTemplates.variant(for: instance.variantID)
+        var resolved = instance
+        if resolved.origin == nil {
+            resolved.origin = nextAutoPlacement(for: variant)
+        }
+
+        let panel = makePanel(for: resolved, variant: variant)
+        windowsByInstanceID[resolved.id] = panel
+        persistUpsert(instance: resolved)
+        if let origin = resolved.origin {
+            panel.setFrameOrigin(NSPoint(x: origin.x, y: origin.y))
+            persistOrigin(instanceID: resolved.id, origin: panel.frame.origin)
+        } else {
+            panel.center()
+            persistOrigin(instanceID: resolved.id, origin: panel.frame.origin)
+        }
+        panel.orderFront(nil)
+        panel.orderFrontRegardless()
+        instancesChangeToken += 1
+    }
+
+    @discardableResult
+    func removeInstances(variantID: String) -> Int {
+        let instances = loadInstances()
+        let removed = instances.filter { $0.variantID == variantID }
+        let remaining = instances.filter { $0.variantID != variantID }
+        for instance in removed {
+            if let panel = windowsByInstanceID.removeValue(forKey: instance.id) {
+                panel.close()
+            }
+        }
+        saveInstances(remaining)
+        instancesChangeToken += 1
+        return removed.count
+    }
+
+    func restore() {
+        for instance in loadInstances() where windowsByInstanceID[instance.id] == nil {
+            show(instance: instance)
+        }
+    }
+
+    func refreshForAuthStateChange() {
+        resizeVisiblePanelsForCurrentContent()
+        authStateRefreshToken += 1
+    }
+
+    private func makePanel(for instance: WidgetInstance, variant: WidgetVariant) -> NSPanel {
+        let size = panelSize(for: variant.size)
+        let panel = DesktopWidgetPanel(
+            contentRect: NSRect(x: 0, y: 0, width: size.width, height: size.height),
+            styleMask: [.nonactivatingPanel, .borderless],
+            backing: .buffered,
+            defer: false
+        )
+        panel.becomesKeyOnlyIfNeeded = false
+        panel.isReleasedWhenClosed = false
+        panel.isFloatingPanel = false
+        panel.isMovable = true
+        panel.hasShadow = false
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.isMovableByWindowBackground = true
+        panel.hidesOnDeactivate = false
+        panel.ignoresMouseEvents = false
+        let desktopIconLevel = Int(CGWindowLevelForKey(.desktopIconWindow))
+        panel.level = NSWindow.Level(rawValue: desktopIconLevel + 1)
+        panel.collectionBehavior = [.canJoinAllSpaces, .stationary, .ignoresCycle]
+
+        let host = NSHostingView(rootView: DesktopWidgetHostView(instanceID: instance.id, variant: variant))
+        host.translatesAutoresizingMaskIntoConstraints = false
+        let container = NSView()
+        container.wantsLayer = true
+        container.layer?.backgroundColor = NSColor.clear.cgColor
+        container.layer?.cornerRadius = 22
+        container.layer?.masksToBounds = true
+        container.addSubview(host)
+        NSLayoutConstraint.activate([
+            host.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            host.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            host.topAnchor.constraint(equalTo: container.topAnchor),
+            host.bottomAnchor.constraint(equalTo: container.bottomAnchor)
+        ])
+        panel.contentView = container
+
+        NotificationCenter.default.addObserver(
+            forName: NSWindow.didMoveNotification,
+            object: panel,
+            queue: .main
+        ) { [weak self, weak panel] _ in
+            guard let self, let panel else { return }
+            self.persistOrigin(instanceID: instance.id, origin: panel.frame.origin)
+        }
+        return panel
+    }
+
+    private func panelSize(for size: WidgetSize) -> CGSize {
+        switch size {
+        case .small:
+            return CGSize(width: 220, height: 204)
+        case .medium:
+            return CGSize(width: 390, height: mediumPanelHeight())
+        case .large:
+            return CGSize(width: 390, height: 398)
+        }
+    }
+
+    private func mediumPanelHeight() -> CGFloat {
+        let visibleMeetingCount = min(loadWidgetMeetingCount(), 2)
+        switch visibleMeetingCount {
+        case 0:
+            return 212
+        case 1:
+            return 226
+        default:
+            return 240
+        }
+    }
+
+    private func loadWidgetMeetingCount() -> Int {
+        let key = WidgetMeetingStore.key
+        guard let data = UserDefaults.standard.data(forKey: key),
+              let meetings = try? JSONDecoder().decode([StoredWidgetMeetingSnapshot].self, from: data) else {
+            return 0
+        }
+        return meetings.count
+    }
+
+    private func resizeVisiblePanelsForCurrentContent() {
+        let instancesByID = Dictionary(uniqueKeysWithValues: loadInstances().map { ($0.id, $0) })
+        for (instanceID, panel) in windowsByInstanceID {
+            guard let instance = instancesByID[instanceID] else { continue }
+            let variant = WidgetTemplates.variant(for: instance.variantID)
+            let targetSize = panelSize(for: variant.size)
+            let currentSize = panel.frame.size
+            guard abs(currentSize.height - targetSize.height) > 0.5 || abs(currentSize.width - targetSize.width) > 0.5 else {
+                continue
+            }
+
+            var frame = panel.frame
+            let oldMaxY = frame.maxY
+            frame.size = targetSize
+            frame.origin.y = oldMaxY - targetSize.height
+            panel.setFrame(frame, display: true)
+            persistOrigin(instanceID: instanceID, origin: frame.origin)
+        }
+    }
+
+    private func nextAutoPlacement(for variant: WidgetVariant) -> WidgetInstance.Origin {
+        let size = panelSize(for: variant.size)
+        let frame = NSScreen.main?.visibleFrame ?? NSRect(x: 100, y: 100, width: 1200, height: 800)
+        let margin: CGFloat = 18
+        let gapX: CGFloat = 22
+        let gapY: CGFloat = 18
+        let cellW = size.width + gapX
+        let cellH = size.height + gapY
+        let existingRects = loadInstances().compactMap { instance -> NSRect? in
+            guard let origin = instance.origin else { return nil }
+            let instanceSize = panelSize(for: instance.size)
+            return NSRect(x: origin.x, y: origin.y, width: instanceSize.width, height: instanceSize.height)
+        }
+
+        let cols = max(1, Int((frame.width - margin * 2) / max(cellW, 1)))
+        let rows = max(1, Int((frame.height - margin * 2) / max(cellH, 1)))
+        let maxSlots = max(120, cols * rows)
+        for slot in 0..<maxSlots {
+            let row = slot / cols
+            let col = cols - 1 - (slot % cols)
+            let x = frame.minX + margin + CGFloat(col) * cellW
+            let y = frame.maxY - margin - size.height - CGFloat(row) * cellH
+            let candidate = NSRect(x: x, y: y, width: size.width, height: size.height)
+            guard candidate.minX >= frame.minX + margin,
+                  candidate.maxX <= frame.maxX - margin,
+                  candidate.minY >= frame.minY + margin else {
+                continue
+            }
+            if !existingRects.contains(where: { $0.intersects(candidate.insetBy(dx: -8, dy: -8)) }) {
+                return WidgetInstance.Origin(x: candidate.minX, y: candidate.minY)
+            }
+        }
+        return WidgetInstance.Origin(
+            x: frame.midX - size.width / 2,
+            y: frame.midY - size.height / 2
+        )
+    }
+
+    private func close(instanceID: UUID) {
+        if let panel = windowsByInstanceID.removeValue(forKey: instanceID) {
+            panel.close()
+        }
+        let remaining = loadInstances().filter { $0.id != instanceID }
+        saveInstances(remaining)
+        instancesChangeToken += 1
+    }
+
+    private func loadInstances() -> [WidgetInstance] {
+        guard let data = UserDefaults.standard.data(forKey: storageKey) else { return [] }
+        let decoded = (try? JSONDecoder().decode([WidgetInstance].self, from: data)) ?? []
+        let allowedByVariantID = Dictionary(uniqueKeysWithValues: WidgetTemplates.meetVariants.map { ($0.id, $0.size) })
+        let sanitized = decoded.compactMap { instance -> WidgetInstance? in
+            guard let expectedSize = allowedByVariantID[instance.variantID] else { return nil }
+            var normalized = instance
+            normalized.size = expectedSize
+            return normalized
+        }
+        if sanitized != decoded {
+            saveInstances(sanitized)
+        }
+        return sanitized
+    }
+
+    private func saveInstances(_ instances: [WidgetInstance]) {
+        guard let data = try? JSONEncoder().encode(instances) else { return }
+        UserDefaults.standard.set(data, forKey: storageKey)
+    }
+
+    private func persistUpsert(instance: WidgetInstance) {
+        var instances = loadInstances()
+        if let idx = instances.firstIndex(where: { $0.id == instance.id }) {
+            instances[idx] = instance
+        } else {
+            instances.append(instance)
+        }
+        saveInstances(instances)
+    }
+
+    private func persistOrigin(instanceID: UUID, origin: NSPoint) {
+        var instances = loadInstances()
+        guard let idx = instances.firstIndex(where: { $0.id == instanceID }) else { return }
+        instances[idx].origin = WidgetInstance.Origin(x: origin.x, y: origin.y)
+        saveInstances(instances)
+    }
+
+    private struct DesktopWidgetHostView: View {
+        let instanceID: UUID
+        let variant: WidgetVariant
+        @ObservedObject private var manager = DesktopWidgetWindowManager.shared
+
+        var body: some View {
+            DesktopWidgetView(variant: variant, isPreview: false)
+                .id(manager.authStateRefreshToken)
+                .contextMenu {
+                    Button("Remove Widget", role: .destructive) {
+                        DesktopWidgetWindowManager.shared.close(instanceID: instanceID)
+                    }
+                }
+        }
+    }
+}
+
+private final class DesktopWidgetPanel: NSPanel {
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { false }
+
+    override func mouseDown(with event: NSEvent) {
+        NSApp.activate(ignoringOtherApps: true)
+        makeKeyAndOrderFront(nil)
+        super.mouseDown(with: event)
+    }
+}

meetings_app/Widgets/WidgetInstance.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+struct WidgetInstance: Identifiable, Codable, Hashable {
+    struct Origin: Codable, Hashable {
+        var x: Double
+        var y: Double
+    }
+
+    let id: UUID
+    let variantID: String
+    var size: WidgetSize
+    var origin: Origin?
+
+    init(id: UUID = UUID(), variantID: String, size: WidgetSize, origin: Origin?) {
+        self.id = id
+        self.variantID = variantID
+        self.size = size
+        self.origin = origin
+    }
+}

meetings_app/Widgets/WidgetPreviewCard.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+struct WidgetPreviewCard: View {
+    let variant: WidgetVariant
+    var layoutScale: CGFloat = 1
+
+    var body: some View {
+        let size = variant.previewCardSize
+        let scale = max(0.01, layoutScale)
+        DesktopWidgetView(variant: variant, isPreview: true)
+            .frame(width: size.width, height: size.height)
+            .scaleEffect(scale)
+            .frame(width: size.width * scale, height: size.height * scale)
+            .clipShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
+            .overlay(
+                RoundedRectangle(cornerRadius: 18, style: .continuous)
+                    .stroke(Color.white.opacity(0.12), lineWidth: 1)
+            )
+    }
+}

meetings_app/Widgets/WidgetSize.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+enum WidgetSize: String, CaseIterable, Codable, Hashable {
+    case small
+    case medium
+    case large
+
+    var title: String {
+        switch self {
+        case .small: return "Small"
+        case .medium: return "Medium"
+        case .large: return "Large"
+        }
+    }
+}

meetings_app/Widgets/WidgetTemplates.swift

@@ -0,0 +1,85 @@
+import Foundation
+import CoreGraphics
+
+struct WidgetQuickAction: Identifiable, Hashable {
+    enum Destination: String, Hashable {
+        case joinMeetings
+        case schedule
+        case calendar
+        case settings
+        case signIn
+        case openMeetWeb
+        case refreshMeetings
+    }
+
+    let id: String
+    let title: String
+    let systemImage: String
+    let destination: Destination
+}
+
+struct WidgetVariant: Identifiable, Hashable {
+    let id: String
+    let title: String
+    let subtitle: String
+    let size: WidgetSize
+    let quickActions: [WidgetQuickAction]
+}
+
+enum WidgetTemplates {
+    static let meetVariants: [WidgetVariant] = [
+        WidgetVariant(
+            id: "meet_small",
+            title: "Google Meet",
+            subtitle: "Open and join quickly",
+            size: .small,
+            quickActions: [
+                WidgetQuickAction(id: "open", title: "Open Meet", systemImage: "video.fill", destination: .openMeetWeb),
+                WidgetQuickAction(id: "join", title: "Join Meetings", systemImage: "arrow.up.forward.app.fill", destination: .joinMeetings)
+            ]
+        ),
+        WidgetVariant(
+            id: "meet_medium",
+            title: "Google Meet",
+            subtitle: "Upcoming meetings",
+            size: .medium,
+            quickActions: [
+                WidgetQuickAction(id: "schedule", title: "Schedule", systemImage: "clock.badge.checkmark", destination: .schedule),
+                WidgetQuickAction(id: "calendar", title: "Calendar", systemImage: "calendar", destination: .calendar),
+                WidgetQuickAction(id: "settings", title: "Settings", systemImage: "gearshape.fill", destination: .settings),
+                WidgetQuickAction(id: "refresh", title: "Refresh", systemImage: "arrow.clockwise", destination: .refreshMeetings)
+            ]
+        ),
+        WidgetVariant(
+            id: "meet_large",
+            title: "Google Meet",
+            subtitle: "Your day at a glance",
+            size: .large,
+            quickActions: [
+                WidgetQuickAction(id: "schedule", title: "Schedule", systemImage: "clock.badge.checkmark", destination: .schedule),
+                WidgetQuickAction(id: "calendar", title: "Calendar", systemImage: "calendar", destination: .calendar),
+                WidgetQuickAction(id: "settings", title: "Settings", systemImage: "gearshape.fill", destination: .settings),
+                WidgetQuickAction(id: "refresh", title: "Refresh", systemImage: "arrow.clockwise", destination: .refreshMeetings),
+                WidgetQuickAction(id: "meet", title: "Open Meet", systemImage: "video.fill", destination: .openMeetWeb),
+                WidgetQuickAction(id: "home", title: "Home", systemImage: "house.fill", destination: .joinMeetings)
+            ]
+        )
+    ]
+
+    static func variant(for variantID: String) -> WidgetVariant {
+        meetVariants.first(where: { $0.id == variantID }) ?? meetVariants[0]
+    }
+}
+
+extension WidgetVariant {
+    var previewCardSize: CGSize {
+        switch size {
+        case .small:
+            return CGSize(width: 196, height: 196)
+        case .medium:
+            return CGSize(width: 340, height: 220)
+        case .large:
+            return CGSize(width: 340, height: 364)
+        }
+    }
+}

meetings_app/Widgets/WidgetsPageFactory.swift

@@ -0,0 +1,13 @@
+import AppKit
+import SwiftUI
+
+func makeWidgetsPageHost(canAddWidgets: Bool, onAddBlocked: @escaping () -> Void) -> NSView {
+    let host = NSHostingView(
+        rootView: WidgetsRootView(
+            canAddWidgets: canAddWidgets,
+            onAddBlocked: onAddBlocked
+        )
+    )
+    host.translatesAutoresizingMaskIntoConstraints = false
+    return host
+}

meetings_app/Widgets/WidgetsRootView.swift

@@ -0,0 +1,147 @@
+import SwiftUI
+
+struct WidgetsRootView: View {
+    @ObservedObject private var desktopWidgetManager = DesktopWidgetWindowManager.shared
+    @Environment(\.colorScheme) private var colorScheme
+    @State private var toastMessage: String?
+    @State private var toastTask: Task<Void, Never>?
+    let canAddWidgets: Bool
+    let onAddBlocked: (() -> Void)?
+
+    private let variants = WidgetTemplates.meetVariants
+
+    init(canAddWidgets: Bool = true, onAddBlocked: (() -> Void)? = nil) {
+        self.canAddWidgets = canAddWidgets
+        self.onAddBlocked = onAddBlocked
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            HStack {
+                VStack(alignment: .leading, spacing: 3) {
+                    Text("Add Widget to Desktop")
+                        .font(.system(size: 20, weight: .bold))
+                    Text("Choose a size and add your Google Meet widget.")
+                        .font(.system(size: 13, weight: .medium))
+                        .foregroundStyle(secondaryTextColor)
+                }
+                Spacer()
+            }
+
+            GeometryReader { geo in
+                let spacing: CGFloat = 18
+                let rowWidth = variants.reduce(CGFloat(0)) { $0 + $1.previewCardSize.width } + CGFloat(max(variants.count - 1, 0)) * spacing
+                let scale = max(0.40, min(1, (geo.size.width - 28) / max(1, rowWidth)))
+                HStack(alignment: .top, spacing: spacing) {
+                    ForEach(variants) { variant in
+                        WidgetPreviewAddCard(
+                            variant: variant,
+                            layoutScale: scale,
+                            isAdded: desktopWidgetManager.hasInstance(variantID: variant.id),
+                            onToggle: { toggleWidget(variant: variant) }
+                        )
+                    }
+                    Spacer(minLength: 0)
+                }
+                .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+            }
+            .frame(height: variants.map(\.previewCardSize.height).max() ?? 320)
+
+            Text("Tip: Right-click a desktop widget to remove it.")
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(secondaryTextColor)
+        }
+        .padding(18)
+        .background(
+            RoundedRectangle(cornerRadius: 18, style: .continuous)
+                .fill(colorScheme == .dark ? Color.white.opacity(0.05) : Color.white.opacity(0.93))
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: 18, style: .continuous)
+                .stroke(colorScheme == .dark ? Color.white.opacity(0.09) : Color.black.opacity(0.08), lineWidth: 1)
+        )
+        .overlay(alignment: .top) {
+            if let toastMessage {
+                Text(toastMessage)
+                    .font(.system(size: 13, weight: .semibold))
+                    .foregroundStyle(colorScheme == .dark ? .white.opacity(0.95) : .primary.opacity(0.95))
+                    .padding(.horizontal, 14)
+                    .padding(.vertical, 9)
+                    .background(
+                        RoundedRectangle(cornerRadius: 12, style: .continuous)
+                            .fill(colorScheme == .dark ? Color.black.opacity(0.82) : Color.white.opacity(0.95))
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 12, style: .continuous)
+                            .stroke(colorScheme == .dark ? Color.white.opacity(0.08) : Color.black.opacity(0.08), lineWidth: 1)
+                    )
+                    .padding(.top, 8)
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+    }
+
+    private var secondaryTextColor: Color {
+        colorScheme == .dark ? .white.opacity(0.72) : .primary.opacity(0.65)
+    }
+
+    private func toggleWidget(variant: WidgetVariant) {
+        if desktopWidgetManager.hasInstance(variantID: variant.id) {
+            let removed = desktopWidgetManager.removeInstances(variantID: variant.id)
+            guard removed > 0 else { return }
+            showToast("Removed \(variant.size.title) widget from desktop.")
+        } else {
+            guard canAddWidgets else {
+                showToast("Widgets are Premium only. Upgrade to add widgets.")
+                onAddBlocked?()
+                return
+            }
+            desktopWidgetManager.show(
+                instance: WidgetInstance(variantID: variant.id, size: variant.size, origin: nil)
+            )
+            showToast("Added \(variant.size.title) widget to desktop.")
+        }
+    }
+
+    private func showToast(_ message: String) {
+        toastTask?.cancel()
+        toastMessage = message
+        toastTask = Task { @MainActor in
+            try? await Task.sleep(nanoseconds: 1_800_000_000)
+            guard !Task.isCancelled else { return }
+            toastMessage = nil
+        }
+    }
+}
+
+private struct WidgetPreviewAddCard: View {
+    let variant: WidgetVariant
+    var layoutScale: CGFloat = 1
+    let isAdded: Bool
+    let onToggle: () -> Void
+    @State private var hovering = false
+
+    var body: some View {
+        ZStack(alignment: .topTrailing) {
+            Button(action: onToggle) {
+                WidgetPreviewCard(variant: variant, layoutScale: layoutScale)
+                    .contentShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
+            }
+            .buttonStyle(.plain)
+
+            Button(action: onToggle) {
+                Image(systemName: isAdded ? "minus" : "plus")
+                    .font(.system(size: 12, weight: .bold))
+                    .foregroundStyle(.white.opacity(0.95))
+                    .frame(width: 26, height: 26)
+                    .background(Circle().fill(isAdded ? Color.red.opacity(0.92) : Color.green.opacity(0.95)))
+                    .shadow(color: .black.opacity(0.28), radius: 10, x: 0, y: 6)
+            }
+            .buttonStyle(.plain)
+            .offset(x: 10 * layoutScale, y: -10 * layoutScale)
+            .opacity(isAdded ? 1 : (hovering ? 1 : 0))
+            .animation(.easeOut(duration: 0.12), value: hovering)
+        }
+        .onHover { hovering = $0 }
+    }
+}