Add Classroom-style enrolled class stream popup.

Implement clickable enrolled class cards with a polished details popover that shows announcements and assignments, supports open-file actions with auth-aware fallback behavior, and handles scope reconsent for announcements access.

Made-with: Cursor

classroom_app/Auth/GoogleOAuthService.swift

@@ -48,6 +48,7 @@ final class GoogleOAuthService: NSObject {
         // Classroom To-do (assignments/quizzes)
         "https://www.googleapis.com/auth/classroom.courses.readonly",
         "https://www.googleapis.com/auth/classroom.coursework.me.readonly",
+        "https://www.googleapis.com/auth/classroom.announcements.readonly",
         "https://www.googleapis.com/auth/classroom.rosters.readonly"
     ]
 

classroom_app/Google/GoogleClassroomClient.swift

@@ -110,6 +110,45 @@ final class GoogleClassroomClient {
         return enrolled
     }
 
+    func fetchClassDetails(accessToken: String, courseId: String, courseName: String) async throws -> ClassroomClassDetails {
+        async let announcementsTask = listCourseAnnouncements(accessToken: accessToken, courseId: courseId, pageSize: 30)
+        async let courseworkTask = listPublishedCourseWork(accessToken: accessToken, courseId: courseId, pageSize: 30)
+        let (announcements, coursework) = try await (announcementsTask, courseworkTask)
+
+        let mappedAnnouncements = announcements.map { item in
+            let text = item.text?.trimmingCharacters(in: .whitespacesAndNewlines)
+            return ClassroomAnnouncement(
+                id: item.id ?? UUID().uuidString,
+                text: (text?.isEmpty == false) ? text! : "Announcement",
+                postedAt: item.createdDate,
+                alternateLink: item.alternateLink.flatMap(URL.init(string:)),
+                attachments: mapMaterialsToAttachments(item.materials)
+            )
+        }.sorted { ($0.postedAt ?? .distantPast) > ($1.postedAt ?? .distantPast) }
+
+        let mappedCourseWork = coursework.map { work in
+            let title = work.title?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let workType = ClassroomTodoWorkType(rawValue: work.workType ?? "") ?? .unspecified
+            return ClassroomCourseWork(
+                id: work.id ?? UUID().uuidString,
+                title: (title?.isEmpty == false) ? title! : "Untitled",
+                subtitle: workType.displayName,
+                dueDate: work.resolvedDueDate,
+                alternateLink: work.alternateLink.flatMap(URL.init(string:)),
+                workType: workType,
+                attachments: mapMaterialsToAttachments(work.materials)
+            )
+        }.sorted { ($0.dueDate ?? .distantFuture) < ($1.dueDate ?? .distantFuture) }
+
+        return ClassroomClassDetails(
+            courseId: courseId,
+            courseName: courseName,
+            courseLink: URL(string: "https://classroom.google.com/c/\(courseId)"),
+            announcements: mappedAnnouncements,
+            coursework: mappedCourseWork
+        )
+    }
+
     // MARK: - Courses
 
     private func listActiveCourses(accessToken: String, pageSize: Int) async throws -> [Course] {
@@ -168,6 +207,35 @@ final class GoogleClassroomClient {
         return decoded.teachers ?? []
     }
 
+    private func listCourseAnnouncements(accessToken: String, courseId: String, pageSize: Int) async throws -> [CourseAnnouncement] {
+        var components = URLComponents(string: "https://classroom.googleapis.com/v1/courses/\(courseId)/announcements")!
+        components.queryItems = [
+            URLQueryItem(name: "announcementStates", value: "PUBLISHED"),
+            URLQueryItem(name: "orderBy", value: "updateTime desc"),
+            URLQueryItem(name: "pageSize", value: String(max(1, min(100, pageSize))))
+        ]
+
+        var request = URLRequest(url: components.url!)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+
+        let decoded: CourseAnnouncementList
+        do {
+            decoded = try JSONDecoder().decode(CourseAnnouncementList.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<unreadable body>"
+            throw GoogleClassroomClientError.decodeFailed(raw)
+        }
+        return decoded.announcements ?? []
+    }
+
     // MARK: - CourseWork
 
     private func listPublishedCourseWork(accessToken: String, courseId: String, pageSize: Int) async throws -> [CourseWork] {
@@ -198,6 +266,66 @@ final class GoogleClassroomClient {
         }
         return decoded.courseWork ?? []
     }
+
+    private func mapMaterialsToAttachments(_ materials: [Material]?) -> [ClassroomAttachment] {
+        guard let materials else { return [] }
+        var attachments: [ClassroomAttachment] = []
+        attachments.reserveCapacity(materials.count)
+
+        for (index, material) in materials.enumerated() {
+            if let drive = material.driveFile?.driveFile,
+               let linkString = drive.alternateLink,
+               let url = URL(string: linkString) {
+                attachments.append(
+                    ClassroomAttachment(
+                        id: drive.id ?? "drive-\(index)",
+                        title: drive.title?.nonEmptyOr("Drive file") ?? "Drive file",
+                        url: url,
+                        mimeType: drive.mimeType,
+                        sourceType: "driveFile"
+                    )
+                )
+            } else if let link = material.link,
+                      let linkString = link.url,
+                      let url = URL(string: linkString) {
+                attachments.append(
+                    ClassroomAttachment(
+                        id: "link-\(index)",
+                        title: link.title?.nonEmptyOr("Link") ?? "Link",
+                        url: url,
+                        mimeType: nil,
+                        sourceType: "link"
+                    )
+                )
+            } else if let form = material.form,
+                      let linkString = form.formUrl,
+                      let url = URL(string: linkString) {
+                attachments.append(
+                    ClassroomAttachment(
+                        id: "form-\(index)",
+                        title: form.title?.nonEmptyOr("Google Form") ?? "Google Form",
+                        url: url,
+                        mimeType: nil,
+                        sourceType: "form"
+                    )
+                )
+            } else if let yt = material.youtubeVideo,
+                      let linkString = yt.alternateLink,
+                      let url = URL(string: linkString) {
+                attachments.append(
+                    ClassroomAttachment(
+                        id: "youtube-\(index)",
+                        title: yt.title?.nonEmptyOr("YouTube") ?? "YouTube",
+                        url: url,
+                        mimeType: nil,
+                        sourceType: "youtubeVideo"
+                    )
+                )
+            }
+        }
+
+        return attachments
+    }
 }
 
 extension GoogleClassroomClientError: LocalizedError {
@@ -241,6 +369,7 @@ private struct CourseWork: Decodable {
     let workType: String?
     let dueDate: DateParts?
     let dueTime: TimeOfDay?
+    let materials: [Material]?
 
     var resolvedDueDate: Date? {
         guard let dueDate else { return nil }
@@ -263,6 +392,24 @@ private struct CourseWork: Decodable {
     }
 }
 
+private struct CourseAnnouncementList: Decodable {
+    let announcements: [CourseAnnouncement]?
+    let nextPageToken: String?
+}
+
+private struct CourseAnnouncement: Decodable {
+    let id: String?
+    let text: String?
+    let alternateLink: String?
+    let creationTime: String?
+    let materials: [Material]?
+
+    var createdDate: Date? {
+        guard let creationTime else { return nil }
+        return Date.parseRFC3339(creationTime)
+    }
+}
+
 private struct DateParts: Decodable {
     let year: Int?
     let month: Int?
@@ -276,6 +423,39 @@ private struct TimeOfDay: Decodable {
     let nanos: Int?
 }
 
+private struct Material: Decodable {
+    let driveFile: SharedDriveFileContainer?
+    let link: SharedLink?
+    let form: SharedForm?
+    let youtubeVideo: SharedYoutubeVideo?
+}
+
+private struct SharedDriveFileContainer: Decodable {
+    let driveFile: SharedDriveFile?
+}
+
+private struct SharedDriveFile: Decodable {
+    let id: String?
+    let title: String?
+    let alternateLink: String?
+    let mimeType: String?
+}
+
+private struct SharedLink: Decodable {
+    let url: String?
+    let title: String?
+}
+
+private struct SharedForm: Decodable {
+    let formUrl: String?
+    let title: String?
+}
+
+private struct SharedYoutubeVideo: Decodable {
+    let alternateLink: String?
+    let title: String?
+}
+
 private struct TeachersList: Decodable {
     let teachers: [Teacher]?
     let nextPageToken: String?
@@ -293,3 +473,21 @@ private struct UserProfile: Decodable {
 private struct UserName: Decodable {
     let fullName: String?
 }
+
+private extension String {
+    func nonEmptyOr(_ fallback: String) -> String {
+        let trimmed = trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? fallback : trimmed
+    }
+}
+
+private extension Date {
+    static func parseRFC3339(_ text: String) -> Date? {
+        let formatterWithFractional = ISO8601DateFormatter()
+        formatterWithFractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let value = formatterWithFractional.date(from: text) { return value }
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: text)
+    }
+}

classroom_app/Models/ClassroomClassFeedItem.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+struct ClassroomClassDetails: Equatable {
+    let courseId: String
+    let courseName: String
+    let courseLink: URL?
+    let announcements: [ClassroomAnnouncement]
+    let coursework: [ClassroomCourseWork]
+}
+
+struct ClassroomAnnouncement: Identifiable, Equatable {
+    let id: String
+    let text: String
+    let postedAt: Date?
+    let alternateLink: URL?
+    let attachments: [ClassroomAttachment]
+}
+
+struct ClassroomCourseWork: Identifiable, Equatable {
+    let id: String
+    let title: String
+    let subtitle: String
+    let dueDate: Date?
+    let alternateLink: URL?
+    let workType: ClassroomTodoWorkType
+    let attachments: [ClassroomAttachment]
+}
+
+struct ClassroomAttachment: Identifiable, Equatable {
+    let id: String
+    let title: String
+    let url: URL
+    let mimeType: String?
+    let sourceType: String
+}

classroom_app/ViewController.swift

@@ -361,6 +361,8 @@ final class ViewController: NSViewController {
     private weak var enrolledPageHeadingLabel: NSTextField?
     private weak var enrolledPageCardsStack: NSStackView?
     private let enrolledSingleCardWidth: CGFloat = 320
+    private var enrolledClassDetailsPopover: NSPopover?
+    private var enrolledCourseByCardID: [String: ClassroomCourse] = [:]
 
     // MARK: - Calendar page (custom month UI)
     private var calendarPageMonthAnchor: Date = Calendar.current.startOfDay(for: Date())
@@ -5405,6 +5407,417 @@ private extension ViewController {
     }
 }
 
+private final class EnrolledClassDetailsViewController: NSViewController {
+    private let details: ClassroomClassDetails
+    private let palette: Palette
+    private let typography: Typography
+    private let defaultAuthorName: String
+    private let defaultAuthorAvatar: NSImage?
+    private let onOpenClass: () -> Void
+    private let onOpenURL: (URL) -> Void
+    private let onDownloadAttachment: (ClassroomAttachment) -> Void
+    private var attachmentByButton = [ObjectIdentifier: ClassroomAttachment]()
+
+    init(details: ClassroomClassDetails,
+         palette: Palette,
+         typography: Typography,
+         defaultAuthorName: String,
+         defaultAuthorAvatar: NSImage?,
+         onOpenClass: @escaping () -> Void,
+         onOpenURL: @escaping (URL) -> Void,
+         onDownloadAttachment: @escaping (ClassroomAttachment) -> Void) {
+        self.details = details
+        self.palette = palette
+        self.typography = typography
+        self.defaultAuthorName = defaultAuthorName
+        self.defaultAuthorAvatar = defaultAuthorAvatar
+        self.onOpenClass = onOpenClass
+        self.onOpenURL = onOpenURL
+        self.onDownloadAttachment = onDownloadAttachment
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    required init?(coder: NSCoder) { nil }
+
+    override func loadView() {
+        let root = NSView()
+        root.translatesAutoresizingMaskIntoConstraints = false
+        root.wantsLayer = true
+        root.layer?.backgroundColor = palette.sectionCard.cgColor
+        root.layer?.cornerRadius = 12
+        root.layer?.borderWidth = 1
+        root.layer?.borderColor = palette.inputBorder.cgColor
+
+        let contentScroll = NSScrollView()
+        contentScroll.translatesAutoresizingMaskIntoConstraints = false
+        contentScroll.drawsBackground = false
+        contentScroll.hasVerticalScroller = true
+        contentScroll.hasHorizontalScroller = false
+        contentScroll.autohidesScrollers = true
+        contentScroll.borderType = .noBorder
+        contentScroll.scrollerStyle = .overlay
+        let clip = TopAlignedClipView()
+        clip.drawsBackground = false
+        contentScroll.contentView = clip
+        root.addSubview(contentScroll)
+
+        let stack = NSStackView()
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        stack.orientation = .vertical
+        stack.alignment = .width
+        stack.spacing = 16
+        contentScroll.documentView = stack
+
+        let pageHeader = makePageHeader()
+        stack.addArrangedSubview(pageHeader)
+
+        if details.announcements.isEmpty, details.coursework.isEmpty {
+            let empty = makeEmptyState()
+            stack.addArrangedSubview(empty)
+            empty.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
+        } else {
+            for item in details.announcements {
+                let card = makeAnnouncementCard(item)
+                stack.addArrangedSubview(card)
+                card.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
+            }
+            for item in details.coursework {
+                let card = makeCourseworkCard(item)
+                stack.addArrangedSubview(card)
+                card.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
+            }
+        }
+
+        NSLayoutConstraint.activate([
+            root.widthAnchor.constraint(equalToConstant: 520),
+            root.heightAnchor.constraint(equalToConstant: 560),
+            contentScroll.leadingAnchor.constraint(equalTo: root.leadingAnchor, constant: 12),
+            contentScroll.trailingAnchor.constraint(equalTo: root.trailingAnchor, constant: -12),
+            contentScroll.topAnchor.constraint(equalTo: root.topAnchor, constant: 12),
+            contentScroll.bottomAnchor.constraint(equalTo: root.bottomAnchor, constant: -12),
+            stack.leadingAnchor.constraint(equalTo: contentScroll.contentView.leadingAnchor),
+            stack.trailingAnchor.constraint(equalTo: contentScroll.contentView.trailingAnchor),
+            stack.topAnchor.constraint(equalTo: contentScroll.contentView.topAnchor),
+            stack.widthAnchor.constraint(equalTo: contentScroll.contentView.widthAnchor),
+            pageHeader.widthAnchor.constraint(equalTo: stack.widthAnchor)
+        ])
+
+        view = root
+    }
+
+    @objc private func openClassPressed(_ sender: NSButton) {
+        onOpenClass()
+    }
+
+    @objc private func openLinkPressed(_ sender: NSButton) {
+        guard let raw = sender.identifier?.rawValue, let url = URL(string: raw) else { return }
+        onOpenURL(url)
+    }
+
+    @objc private func downloadPressed(_ sender: NSButton) {
+        guard let attachment = attachmentByButton[ObjectIdentifier(sender)] else { return }
+        onDownloadAttachment(attachment)
+    }
+
+    private func makePageHeader() -> NSView {
+        let title = NSTextField(labelWithString: details.courseName)
+        title.font = NSFont.systemFont(ofSize: 18, weight: .bold)
+        title.textColor = palette.textPrimary
+        title.maximumNumberOfLines = 2
+        title.lineBreakMode = .byWordWrapping
+
+        let subtitle = NSTextField(labelWithString: "Class stream")
+        subtitle.font = NSFont.systemFont(ofSize: 12, weight: .medium)
+        subtitle.textColor = palette.textMuted
+
+        let openClassButton = NSButton(title: "Open in Classroom", target: self, action: #selector(openClassPressed(_:)))
+        openClassButton.bezelStyle = .rounded
+        openClassButton.font = NSFont.systemFont(ofSize: 12, weight: .semibold)
+
+        let left = NSStackView(views: [title, subtitle])
+        left.orientation = .vertical
+        left.alignment = .leading
+        left.spacing = 4
+
+        let row = NSStackView(views: [left, NSView(), openClassButton])
+        row.translatesAutoresizingMaskIntoConstraints = false
+        row.orientation = .horizontal
+        row.alignment = .centerY
+
+        let card = makeStreamCardShell()
+        card.addSubview(row)
+        NSLayoutConstraint.activate([
+            row.leadingAnchor.constraint(equalTo: card.leadingAnchor, constant: 14),
+            row.trailingAnchor.constraint(equalTo: card.trailingAnchor, constant: -14),
+            row.topAnchor.constraint(equalTo: card.topAnchor, constant: 12),
+            row.bottomAnchor.constraint(equalTo: card.bottomAnchor, constant: -12)
+        ])
+        return card
+    }
+
+    private func makeEmptyState() -> NSView {
+        let card = makeStreamCardShell()
+        let stack = NSStackView()
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        stack.orientation = .vertical
+        stack.alignment = .centerX
+        stack.spacing = 8
+
+        let title = NSTextField(labelWithString: "No stream items yet")
+        title.font = NSFont.systemFont(ofSize: 14, weight: .semibold)
+        title.textColor = palette.textPrimary
+
+        let subtitle = NSTextField(labelWithString: "Announcements and coursework will appear here.")
+        subtitle.font = typography.cardSubtitle
+        subtitle.textColor = palette.textSecondary
+
+        stack.addArrangedSubview(title)
+        stack.addArrangedSubview(subtitle)
+        card.addSubview(stack)
+        NSLayoutConstraint.activate([
+            stack.centerXAnchor.constraint(equalTo: card.centerXAnchor),
+            stack.centerYAnchor.constraint(equalTo: card.centerYAnchor),
+            stack.leadingAnchor.constraint(greaterThanOrEqualTo: card.leadingAnchor, constant: 16),
+            stack.trailingAnchor.constraint(lessThanOrEqualTo: card.trailingAnchor, constant: -16),
+            card.heightAnchor.constraint(equalToConstant: 120)
+        ])
+        return card
+    }
+
+    private func makeMutedLabel(_ text: String) -> NSTextField {
+        let label = NSTextField(labelWithString: text)
+        label.font = typography.cardSubtitle
+        label.textColor = palette.textSecondary
+        return label
+    }
+
+    private func makeAnnouncementCard(_ item: ClassroomAnnouncement) -> NSView {
+        let container = NSStackView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+        container.orientation = .vertical
+        container.alignment = .leading
+        container.spacing = 10
+        container.addArrangedSubview(makeStreamMetaRow(authorName: defaultAuthorName, date: item.postedAt))
+        container.addArrangedSubview(makeBodyLabel(item.text))
+        if !item.attachments.isEmpty {
+            container.addArrangedSubview(makeAttachmentPreview(item.attachments[0]))
+        }
+        if let link = item.alternateLink {
+            let open = makeInlineActionButton(title: "Open announcement", url: link)
+            container.addArrangedSubview(open)
+        }
+        container.addArrangedSubview(makeCommentRow())
+        return wrapInStreamCard(container)
+    }
+
+    private func makeCourseworkCard(_ item: ClassroomCourseWork) -> NSView {
+        let container = NSStackView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+        container.orientation = .vertical
+        container.alignment = .leading
+        container.spacing = 10
+
+        container.addArrangedSubview(makeStreamMetaRow(authorName: defaultAuthorName, date: item.dueDate))
+        let headline = "\(defaultAuthorName) posted a new \(item.subtitle.lowercased()): \(item.title)"
+        container.addArrangedSubview(makeBodyLabel(headline))
+        if !item.attachments.isEmpty {
+            container.addArrangedSubview(makeAttachmentPreview(item.attachments[0]))
+        }
+        if let link = item.alternateLink {
+            let open = makeInlineActionButton(title: "Open item", url: link)
+            container.addArrangedSubview(open)
+        }
+        return wrapInStreamCard(container)
+    }
+
+    private func makeAttachmentsList(_ attachments: [ClassroomAttachment]) -> NSView {
+        let stack = NSStackView()
+        stack.orientation = .vertical
+        stack.alignment = .leading
+        stack.spacing = 2
+
+        let header = NSTextField(labelWithString: "Attachments")
+        header.font = NSFont.systemFont(ofSize: 12, weight: .semibold)
+        header.textColor = palette.textMuted
+        stack.addArrangedSubview(header)
+
+        for attachment in attachments {
+            let button = NSButton(title: "Open file: \(attachment.title)", target: self, action: #selector(downloadPressed(_:)))
+            button.bezelStyle = .inline
+            button.font = NSFont.systemFont(ofSize: 12, weight: .medium)
+            attachmentByButton[ObjectIdentifier(button)] = attachment
+            stack.addArrangedSubview(button)
+        }
+        return stack
+    }
+
+    private func makeStreamMetaRow(authorName: String, date: Date?) -> NSView {
+        let avatar = NSImageView()
+        avatar.translatesAutoresizingMaskIntoConstraints = false
+        if let defaultAuthorAvatar {
+            avatar.image = circularNSImage(defaultAuthorAvatar, diameter: 34)
+            avatar.contentTintColor = nil
+        } else {
+            avatar.image = NSImage(systemSymbolName: "person.crop.circle.fill", accessibilityDescription: "Author")
+            avatar.symbolConfiguration = NSImage.SymbolConfiguration(pointSize: 28, weight: .regular)
+            avatar.contentTintColor = palette.textSecondary
+        }
+        avatar.widthAnchor.constraint(equalToConstant: 34).isActive = true
+        avatar.heightAnchor.constraint(equalToConstant: 34).isActive = true
+
+        let name = NSTextField(labelWithString: authorName)
+        name.font = NSFont.systemFont(ofSize: 14, weight: .bold)
+        name.textColor = palette.textPrimary
+
+        let time = makeMutedLabel(timeText(date))
+        time.font = NSFont.systemFont(ofSize: 12, weight: .medium)
+
+        let nameTime = NSStackView(views: [name, time])
+        nameTime.orientation = .vertical
+        nameTime.alignment = .leading
+        nameTime.spacing = 2
+
+        let menu = NSTextField(labelWithString: "⋮")
+        menu.font = NSFont.systemFont(ofSize: 18, weight: .semibold)
+        menu.textColor = palette.textMuted
+
+        let row = NSStackView(views: [avatar, nameTime, NSView(), menu])
+        row.orientation = .horizontal
+        row.alignment = .top
+        row.distribution = .fill
+        return row
+    }
+
+    private func makeBodyLabel(_ text: String) -> NSView {
+        let body = NSTextField(wrappingLabelWithString: text)
+        body.maximumNumberOfLines = 0
+        body.font = NSFont.systemFont(ofSize: 15, weight: .regular)
+        body.textColor = palette.textPrimary
+        return body
+    }
+
+    private func makeCommentRow() -> NSView {
+        let divider = NSBox()
+        divider.boxType = .separator
+        divider.translatesAutoresizingMaskIntoConstraints = false
+
+        let comment = NSTextField(labelWithString: "Add comment")
+        comment.font = NSFont.systemFont(ofSize: 13, weight: .semibold)
+        comment.textColor = palette.primaryBlue
+
+        let icon = NSImageView()
+        icon.translatesAutoresizingMaskIntoConstraints = false
+        icon.image = NSImage(systemSymbolName: "bubble.left.and.bubble.right", accessibilityDescription: nil)
+        icon.symbolConfiguration = NSImage.SymbolConfiguration(pointSize: 13, weight: .medium)
+        icon.contentTintColor = palette.primaryBlue
+        icon.widthAnchor.constraint(equalToConstant: 15).isActive = true
+        icon.heightAnchor.constraint(equalToConstant: 15).isActive = true
+
+        let row = NSStackView(views: [icon, comment])
+        row.orientation = .horizontal
+        row.alignment = .centerY
+        row.spacing = 8
+
+        let container = NSStackView(views: [divider, row])
+        container.orientation = .vertical
+        container.alignment = .width
+        container.spacing = 10
+        return container
+    }
+
+    private func makeAttachmentPreview(_ attachment: ClassroomAttachment) -> NSView {
+        let preview = NSView()
+        preview.translatesAutoresizingMaskIntoConstraints = false
+        preview.wantsLayer = true
+        preview.layer?.cornerRadius = 12
+        preview.layer?.backgroundColor = palette.sectionCard.cgColor
+        preview.layer?.borderWidth = 1
+        preview.layer?.borderColor = palette.inputBorder.cgColor
+
+        let titleButton = NSButton(title: attachment.title, target: self, action: #selector(downloadPressed(_:)))
+        titleButton.translatesAutoresizingMaskIntoConstraints = false
+        titleButton.bezelStyle = .inline
+        titleButton.font = NSFont.systemFont(ofSize: 16, weight: .semibold)
+        titleButton.contentTintColor = palette.primaryBlue
+        attachmentByButton[ObjectIdentifier(titleButton)] = attachment
+
+        let type = makeMutedLabel(attachment.mimeType ?? attachment.sourceType.capitalized)
+        type.translatesAutoresizingMaskIntoConstraints = false
+
+        let textCol = NSStackView(views: [titleButton, type])
+        textCol.translatesAutoresizingMaskIntoConstraints = false
+        textCol.orientation = .vertical
+        textCol.alignment = .leading
+        textCol.spacing = 2
+
+        let thumb = NSImageView()
+        thumb.translatesAutoresizingMaskIntoConstraints = false
+        thumb.image = NSImage(systemSymbolName: "doc.richtext", accessibilityDescription: nil)
+        thumb.symbolConfiguration = NSImage.SymbolConfiguration(pointSize: 20, weight: .medium)
+        thumb.contentTintColor = palette.textMuted
+        thumb.wantsLayer = true
+        thumb.layer?.backgroundColor = palette.inputBackground.cgColor
+        thumb.layer?.cornerRadius = 8
+        thumb.widthAnchor.constraint(equalToConstant: 88).isActive = true
+
+        preview.addSubview(textCol)
+        preview.addSubview(thumb)
+        NSLayoutConstraint.activate([
+            preview.heightAnchor.constraint(equalToConstant: 90),
+            textCol.leadingAnchor.constraint(equalTo: preview.leadingAnchor, constant: 12),
+            textCol.trailingAnchor.constraint(equalTo: thumb.leadingAnchor, constant: -10),
+            textCol.centerYAnchor.constraint(equalTo: preview.centerYAnchor),
+            thumb.trailingAnchor.constraint(equalTo: preview.trailingAnchor, constant: -10),
+            thumb.topAnchor.constraint(equalTo: preview.topAnchor, constant: 10),
+            thumb.bottomAnchor.constraint(equalTo: preview.bottomAnchor, constant: -10)
+        ])
+        return preview
+    }
+
+    private func makeInlineActionButton(title: String, url: URL) -> NSButton {
+        let open = NSButton(title: title, target: self, action: #selector(openLinkPressed(_:)))
+        open.bezelStyle = .inline
+        open.identifier = NSUserInterfaceItemIdentifier(url.absoluteString)
+        open.font = NSFont.systemFont(ofSize: 12, weight: .semibold)
+        return open
+    }
+
+    private func makeStreamCardShell() -> NSView {
+        let card = NSView()
+        card.translatesAutoresizingMaskIntoConstraints = false
+        card.wantsLayer = true
+        card.layer?.cornerRadius = 10
+        card.layer?.backgroundColor = palette.inputBackground
+            .blended(withFraction: 0.32, of: palette.sectionCard)?
+            .cgColor ?? palette.inputBackground.cgColor
+        card.layer?.borderWidth = 1
+        card.layer?.borderColor = palette.inputBorder.cgColor
+        return card
+    }
+
+    private func wrapInStreamCard(_ content: NSView) -> NSView {
+        let card = makeStreamCardShell()
+        card.addSubview(content)
+        NSLayoutConstraint.activate([
+            content.leadingAnchor.constraint(equalTo: card.leadingAnchor, constant: 12),
+            content.trailingAnchor.constraint(equalTo: card.trailingAnchor, constant: -12),
+            content.topAnchor.constraint(equalTo: card.topAnchor, constant: 10),
+            content.bottomAnchor.constraint(equalTo: card.bottomAnchor, constant: -10),
+            card.widthAnchor.constraint(greaterThanOrEqualToConstant: 220)
+        ])
+        return card
+    }
+
+    private func timeText(_ date: Date?) -> String {
+        guard let date else { return "Just now" }
+        let formatter = DateFormatter()
+        formatter.locale = Locale.current
+        formatter.timeStyle = .short
+        formatter.dateStyle = .none
+        return formatter.string(from: date)
+    }
+}
+
 private final class CalendarDayActionMenuViewController: NSViewController {
     private let palette: Palette
     private let onSchedule: () -> Void
@@ -6088,6 +6501,7 @@ private extension ViewController {
 
     private func renderEnrolledClassCards(_ courses: [ClassroomCourse]) {
         guard let stack = enrolledPageCardsStack else { return }
+        enrolledCourseByCardID.removeAll()
 
         stack.arrangedSubviews.forEach { view in
             stack.removeArrangedSubview(view)
@@ -6121,7 +6535,7 @@ private extension ViewController {
 
         let isSingleCard = (courses.count == 1)
         for course in courses {
-            let card = enrolledClassCard(course: course)
+            let card = enrolledClassCardButton(course: course)
             stack.addArrangedSubview(card)
             if isSingleCard {
                 card.widthAnchor.constraint(equalToConstant: enrolledSingleCardWidth).isActive = true
@@ -6132,6 +6546,41 @@ private extension ViewController {
         }
     }
 
+    private func enrolledClassCardButton(course: ClassroomCourse) -> NSView {
+        let hit = HoverButton(title: "", target: self, action: #selector(enrolledCardButtonPressed(_:)))
+        hit.translatesAutoresizingMaskIntoConstraints = false
+        hit.isBordered = false
+        hit.bezelStyle = .regularSquare
+        hit.wantsLayer = true
+        hit.identifier = NSUserInterfaceItemIdentifier(course.id)
+        enrolledCourseByCardID[course.id] = course
+        hit.heightAnchor.constraint(greaterThanOrEqualToConstant: 124).isActive = true
+
+        let card = enrolledClassCard(course: course)
+        hit.addSubview(card)
+        NSLayoutConstraint.activate([
+            card.leadingAnchor.constraint(equalTo: hit.leadingAnchor),
+            card.trailingAnchor.constraint(equalTo: hit.trailingAnchor),
+            card.topAnchor.constraint(equalTo: hit.topAnchor),
+            card.bottomAnchor.constraint(equalTo: hit.bottomAnchor)
+        ])
+        hit.onHoverChanged = { [weak self, weak card] hovering in
+            guard let self, let card else { return }
+            let base = self.palette.sectionCard
+            let hoverBlend = self.darkModeEnabled ? NSColor.white : NSColor.black
+            let hover = base.blended(withFraction: 0.10, of: hoverBlend) ?? base
+            card.layer?.backgroundColor = (hovering ? hover : base).cgColor
+        }
+        hit.onHoverChanged?(false)
+        return hit
+    }
+
+    @objc private func enrolledCardButtonPressed(_ sender: NSButton) {
+        guard let courseID = sender.identifier?.rawValue,
+              let course = enrolledCourseByCardID[courseID] else { return }
+        enrolledClassCardClicked(view: sender, course: course)
+    }
+
     private func enrolledClassCard(course: ClassroomCourse) -> NSView {
         let card = roundedContainer(cornerRadius: 14, color: palette.sectionCard)
         card.translatesAutoresizingMaskIntoConstraints = false
@@ -6181,6 +6630,142 @@ private extension ViewController {
         return card
     }
 
+    private func enrolledClassCardClicked(view: NSView, course: ClassroomCourse) {
+        Task { [weak self, weak view] in
+            guard let self, let view else { return }
+            do {
+                if self.googleOAuth.loadTokens() == nil {
+                    await MainActor.run {
+                        self.showSimpleAlert(title: "Connect Google", message: "Connect your Google account to view class details.")
+                    }
+                    return
+                }
+                let token = try await self.googleOAuth.validAccessToken(presentingWindow: self.view.window)
+                let details = try await self.classroomClient.fetchClassDetails(
+                    accessToken: token,
+                    courseId: course.id,
+                    courseName: course.name
+                )
+                await MainActor.run {
+                    let authorName = course.teacherNames.first ?? "Classroom"
+                    self.showEnrolledClassDetailsPopover(details: details, defaultAuthorName: authorName, relativeTo: view)
+                }
+            } catch {
+                await MainActor.run {
+                    if self.errorRequiresReconsentForClassroomScopes(error) {
+                        _ = try? self.googleOAuth.signOut()
+                        self.applyGoogleProfile(nil)
+                        self.updateGoogleAuthButtonTitle()
+                        self.showSimpleAlert(
+                            title: "Reconnect Google",
+                            message: "We added new Google Classroom permissions for class announcements. Please reconnect your Google account and grant access."
+                        )
+                        return
+                    }
+                    self.showSimpleError("Couldn’t load class details.", error: error)
+                }
+            }
+        }
+    }
+
+    private func showEnrolledClassDetailsPopover(details: ClassroomClassDetails, defaultAuthorName: String, relativeTo anchor: NSView) {
+        enrolledClassDetailsPopover?.performClose(nil)
+        let popover = NSPopover()
+        popover.behavior = .transient
+        popover.animates = true
+        popover.appearance = NSAppearance(named: darkModeEnabled ? .darkAqua : .aqua)
+        popover.contentViewController = EnrolledClassDetailsViewController(
+            details: details,
+            palette: palette,
+            typography: typography,
+            defaultAuthorName: defaultAuthorName,
+            defaultAuthorAvatar: scheduleProfileMenuAvatar,
+            onOpenClass: { [weak self] in
+                guard let self, let url = details.courseLink else { return }
+                self.openURL(url)
+            },
+            onOpenURL: { [weak self] url in
+                self?.openURL(url)
+            },
+            onDownloadAttachment: { [weak self] attachment in
+                self?.downloadClassAttachment(attachment)
+            }
+        )
+        enrolledClassDetailsPopover = popover
+        popover.show(relativeTo: anchor.bounds, of: anchor, preferredEdge: .maxX)
+    }
+
+    private func downloadClassAttachment(_ attachment: ClassroomAttachment) {
+        Task { [weak self] in
+            guard let self else { return }
+            do {
+                let token = try? await self.googleOAuth.validAccessToken(presentingWindow: self.view.window)
+                var request = URLRequest(url: attachment.url)
+                request.httpMethod = "GET"
+                if let token {
+                    request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+                }
+                let (data, response) = try await URLSession.shared.data(for: request)
+                if let http = response as? HTTPURLResponse, !(200..<300).contains(http.statusCode) {
+                    if http.statusCode == 401 || http.statusCode == 403 {
+                        await MainActor.run {
+                            self.openURL(attachment.url)
+                        }
+                        return
+                    }
+                    let body = String(data: data, encoding: .utf8) ?? "<no body>"
+                    throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+                }
+                if let http = response as? HTTPURLResponse,
+                   let contentType = http.value(forHTTPHeaderField: "Content-Type")?.lowercased(),
+                   contentType.contains("text/html") {
+                    await MainActor.run {
+                        self.openURL(attachment.url)
+                    }
+                    return
+                }
+                let destination = try self.uniqueDownloadURL(for: attachment)
+                try data.write(to: destination)
+                await MainActor.run {
+                    _ = NSWorkspace.shared.open(destination)
+                }
+            } catch {
+                await MainActor.run {
+                    self.showSimpleError("Couldn’t download attachment.", error: error)
+                }
+            }
+        }
+    }
+
+    private func uniqueDownloadURL(for attachment: ClassroomAttachment) throws -> URL {
+        let fileManager = FileManager.default
+        let downloadsDir = try fileManager.url(
+            for: .downloadsDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )
+
+        let preferredName = attachment.title.trimmingCharacters(in: .whitespacesAndNewlines)
+        let fallbackName = attachment.url.lastPathComponent.isEmpty ? "attachment" : attachment.url.lastPathComponent
+        let originalName = (preferredName.isEmpty ? fallbackName : preferredName)
+        let originalExtension = (attachment.url.pathExtension.isEmpty ? URL(fileURLWithPath: originalName).pathExtension : attachment.url.pathExtension)
+        let baseName = URL(fileURLWithPath: originalName).deletingPathExtension().lastPathComponent
+
+        var candidate = downloadsDir.appendingPathComponent(originalName)
+        if fileManager.fileExists(atPath: candidate.path) == false { return candidate }
+
+        var index = 1
+        while true {
+            let numbered = "\(baseName)-\(index)\(originalExtension.isEmpty ? "" : ".\(originalExtension)")"
+            candidate = downloadsDir.appendingPathComponent(numbered)
+            if fileManager.fileExists(atPath: candidate.path) == false {
+                return candidate
+            }
+            index += 1
+        }
+    }
+
     private func renderScheduleCards(into stack: NSStackView, todos: [ClassroomTodoItem]) {
         displayedScheduleTodos = todos
         let shouldShowScrollControls = todos.count > 3