Commit `4c312827dd`

4c312827ddbea8ca40c78f0d3aa82a696377a5f4

parent: 787436c54e

Unsigned

cmc <hello@cleberg.net> · 2026-03-19 06:53 UTC

feat: add inbox threads and move builds under more

Layout: unified · split

Hutch/App/RootView.swift +13 −13

                 Label("Repositories", systemImage: "book.closed")
             }
-            NavigationStack(path: $buildsPath) {
-                BuildListView()
-                    // Int destination used by deep links (hutch://builds/<id>).
-                    // JobSummary destination is registered inside BuildListView.
-                    .navigationDestination(for: Int.self) { jobId in
-                        BuildDetailView(jobId: jobId)
-                    }
-            }
-            .tag(AppState.Tab.builds)
-            .tabItem {
-                Label("Builds", systemImage: "hammer")
-            }
             NavigationStack(path: $ticketsPath) {
                 TrackerListView()
                     // Deep link destination for jumping straight to a ticket.
                 .tabItem {
                     Label("Settings", systemImage: "gear")
                 }
+            NavigationStack(path: $buildsPath) {
+                BuildListView()
+                    // Int destination used by deep links (hutch://builds/<id>).
+                    // JobSummary destination is registered inside BuildListView.
+                    .navigationDestination(for: Int.self) { jobId in
+                        BuildDetailView(jobId: jobId)
+                    }
+            }
+            .tag(AppState.Tab.builds)
+            .tabItem {
+                Label("Builds", systemImage: "hammer")
+            }
         }
         .overlay {
             if isResolvingDeepLink {

Hutch/Models/Inbox.swift +6

         defaults.set(dictionary, forKey: key)
     }
+    static func markUnread(for threadID: String, defaults: UserDefaults = .standard) {
+        var dictionary = defaults.dictionary(forKey: key) as? [String: TimeInterval] ?? [:]
+        dictionary.removeValue(forKey: threadID)
+        defaults.set(dictionary, forKey: key)
+    }
     static func isUnread(threadID: String, lastActivityAt: Date, defaults: UserDefaults = .standard) -> Bool {
         guard let lastViewedAt = lastViewedAt(for: threadID, defaults: defaults) else {
             return true

Hutch/Views/Inbox/InboxView.swift +22 −1

	@@ -31,6 +31,12 @@ struct InboxView: View {
31	NavigationLink(value: thread) {	31	NavigationLink(value: thread) {
32	InboxThreadRow(thread: thread)	32	InboxThreadRow(thread: thread)
33	}	33	}
		34	.swipeActions(edge: .leading, allowsFullSwipe: true) {
		35	readStateAction(for: thread, in: viewModel)
		36	}
		37	.swipeActions(edge: .trailing, allowsFullSwipe: true) {
		38	readStateAction(for: thread, in: viewModel)
		39	}
34	}	40	}
35	}	41	}
36	.listStyle(.plain)	42	.listStyle(.plain)
	@@ -39,7 +45,7 @@ struct InboxView: View {
39	SRHTLoadingStateView(message: "Loading inbox…")	45	SRHTLoadingStateView(message: "Loading inbox…")
40	} else if let error = viewModel.error, viewModel.threads.isEmpty {	46	} else if let error = viewModel.error, viewModel.threads.isEmpty {
41	SRHTErrorStateView(	47	SRHTErrorStateView(
42	title: "Couldn't Load Threads",	48	title: "Failed to load inbox",
43	message: error,	49	message: error,
44	retryAction: { await viewModel.loadThreads() }	50	retryAction: { await viewModel.loadThreads() }
45	)	51	)
	@@ -64,6 +70,21 @@ struct InboxView: View {
64	}	70	}
65	}	71	}
66	}	72	}
		73
		74	@ViewBuilder
		75	private func readStateAction(for thread: InboxThreadSummary, in viewModel: InboxViewModel) -> some View {
		76	Button {
		77	withAnimation(.easeInOut(duration: 0.2)) {
		78	viewModel.toggleThreadReadState(thread)
		79	}
		80	} label: {
		81	Label(
		82	thread.isUnread ? "Mark as Read" : "Mark as Unread",
		83	systemImage: thread.isUnread ? "envelope.open" : "envelope.badge"
		84	)
		85	}
		86	.tint(thread.isUnread ? .blue : .gray)
		87	}
67	}	88	}
68		89
69	private struct InboxThreadRow: View {	90	private struct InboxThreadRow: View {

Hutch/Views/Inbox/InboxViewModel.swift +53 −23

                 return lhs.lastActivityAt > rhs.lastActivityAt
             }
         } catch {
-            threads = []
+            inboxListLogger.error("Inbox request failed: type=inbox error=\(error.localizedDescription, privacy: .public)")
-            self.error = error.localizedDescription
+            self.error = "Failed to load inbox"
         }
     }
     func markThreadRead(_ thread: InboxThreadSummary) {
         let viewedAt = max(Date(), thread.lastActivityAt)
         InboxReadStateStore.markViewed(viewedAt, for: thread.id)
-        guard let index = threads.firstIndex(where: { $0.id == thread.id }) else { return }
+        inboxListLogger.debug(
-        let current = threads[index]
+            "Inbox mark read: key=\(thread.id, privacy: .public) latestActivityAt=\(thread.lastActivityAt.ISO8601Format(), privacy: .public) storedLastViewedAt=\(viewedAt.ISO8601Format(), privacy: .public)"
-        threads[index] = InboxThreadSummary(
-            rootEmailID: current.rootEmailID,
-            rootMessageID: current.rootMessageID,
-            threadRootEmailIDs: current.threadRootEmailIDs,
-            threadRootMessageIDs: current.threadRootMessageIDs,
-            listID: current.listID,
-            listRID: current.listRID,
-            listName: current.listName,
-            listOwner: current.listOwner,
-            subject: current.subject,
-            latestSender: current.latestSender,
-            lastActivityAt: current.lastActivityAt,
-            messageCount: current.messageCount,
-            repo: current.repo,
-            containsPatch: current.containsPatch,
-            isUnread: false
         )
+        updateThread(thread, isUnread: false)
+    }
+    func markThreadUnread(_ thread: InboxThreadSummary) {
+        InboxReadStateStore.markUnread(for: thread.id)
+        inboxListLogger.debug(
+            "Inbox mark unread: key=\(thread.id, privacy: .public) latestActivityAt=\(thread.lastActivityAt.ISO8601Format(), privacy: .public) storedLastViewedAt=nil"
+        )
+        updateThread(thread, isUnread: true)
+    }
+    func toggleThreadReadState(_ thread: InboxThreadSummary) {
+        if thread.isUnread {
+            markThreadRead(thread)
+        } else {
+            markThreadUnread(thread)
+        }
     }
     private func fetchSubscriptions() async throws -> [InboxActivitySubscription] {
                         do {
                             return (try await self.fetchThreads(for: mailingList), nil)
                         } catch {
-                            return ([], error.localizedDescription)
+                            return ([], "rid=\(mailingList.rid) error=\(error.localizedDescription)")
                         }
                     }
                 }
             summaries.append(contentsOf: batchResult.0)
             failureMessages.append(contentsOf: batchResult.1)
+            for failure in batchResult.1 {
+                inboxListLogger.error("Inbox request failed: type=listThreads \(failure, privacy: .public)")
+            }
             startIndex = endIndex
         }
         )
         return response.list.threads.results.prefix(listThreadFetchLimit).map { thread in
-            let threadID = "\(mailingList.rid)#\(thread.root.messageID)"
             let groupingKey = "\(mailingList.rid)#\(thread.subject.replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression).trimmingCharacters(in: .whitespacesAndNewlines).replacingOccurrences(of: #"^(?:(?:re|fwd?)\s*:\s*)+"#, with: "", options: [.regularExpression, .caseInsensitive]).lowercased())"
+            let lastViewedAt = InboxReadStateStore.lastViewedAt(for: groupingKey)
+            let isUnread = InboxReadStateStore.isUnread(threadID: groupingKey, lastActivityAt: thread.updated)
             inboxListLogger.debug(
                 "Inbox thread grouping candidate: listRID=\(mailingList.rid, privacy: .public) rootMessageID=\(thread.root.messageID, privacy: .public) rootEmailID=\(thread.root.id, privacy: .public) groupingKey=\(groupingKey, privacy: .public)"
             )
+            inboxListLogger.debug(
+                "Inbox unread state: key=\(groupingKey, privacy: .public) latestActivityAt=\(thread.updated.ISO8601Format(), privacy: .public) lastViewedAt=\(lastViewedAt?.ISO8601Format() ?? "nil", privacy: .public) isUnread=\(isUnread, privacy: .public)"
+            )
             return InboxThreadSummary(
                 rootEmailID: thread.root.id,
                 rootMessageID: thread.root.messageID,
                 messageCount: thread.replies + 1,
                 repo: Self.deriveRepositoryName(from: mailingList.name),
                 containsPatch: thread.root.patch != nil || thread.subject.localizedCaseInsensitiveContains("[patch"),
-                isUnread: InboxReadStateStore.isUnread(threadID: threadID, lastActivityAt: thread.updated)
+                isUnread: isUnread
             )
         }
     }
         }
     }
+    private func updateThread(_ thread: InboxThreadSummary, isUnread: Bool) {
+        guard let index = threads.firstIndex(where: { $0.id == thread.id }) else { return }
+        let current = threads[index]
+        threads[index] = InboxThreadSummary(
+            rootEmailID: current.rootEmailID,
+            rootMessageID: current.rootMessageID,
+            threadRootEmailIDs: current.threadRootEmailIDs,
+            threadRootMessageIDs: current.threadRootMessageIDs,
+            listID: current.listID,
+            listRID: current.listRID,
+            listName: current.listName,
+            listOwner: current.listOwner,
+            subject: current.subject,
+            latestSender: current.latestSender,
+            lastActivityAt: current.lastActivityAt,
+            messageCount: current.messageCount,
+            repo: current.repo,
+            containsPatch: current.containsPatch,
+            isUnread: isUnread
+        )
+    }
     private func deduplicateMailingLists(_ mailingLists: [InboxMailingListReference]) -> [InboxMailingListReference] {
         var seen = Set<String>()
         return mailingLists.filter { mailingList in

Hutch/Views/Inbox/ThreadDetailView.swift +9 −1

                     .padding(.vertical, 4)
                 }
+                if let partialWarning = viewModel.partialWarning {
+                    Section {
+                        Text(partialWarning)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
                 ForEach(thread.messages) { message in
                     InboxMessageRow(message: message)
                 }
                 SRHTLoadingStateView(message: "Loading thread…")
             } else if let error = viewModel.error, viewModel.thread == nil {
                 SRHTErrorStateView(
-                    title: "Couldn't Load Thread",
+                    title: "Failed to load thread",
                     message: error,
                     retryAction: { await viewModel.loadThread() }
                 )

Hutch/Views/Inbox/ThreadViewModel.swift +87 −29

     private(set) var thread: InboxThreadDetail?
     private(set) var isLoading = false
     var error: String?
+    var partialWarning: String?
     var composeDraft: MailComposeDraft?
     private let summary: InboxThreadSummary
         guard !isLoading else { return }
         isLoading = true
         error = nil
+        partialWarning = nil
         defer { isLoading = false }
         inboxLogger.debug("Opening inbox thread: \(self.summary.debugIdentifierSummary, privacy: .public)")
             )
             var messagesByID: [Int: InboxMessage] = [:]
+            var hadPartialReplyFailure = false
             for payload in threadPayloads {
                 guard let rootMessage = Self.message(from: payload.root, fallbackID: summary.rootEmailID) else {
                     continue
                 }
                 messagesByID[rootMessage.id] = rootMessage
-                let descendantMessages = try await fetchAllDescendantMessages(
+                do {
-                    initialPayload: payload,
+                    let descendantMessages = try await fetchAllDescendantMessages(
-                    candidateMessageIDs: Self.messageIDCandidates(from: payload.root?.messageID ?? summary.rootMessageID)
+                        initialPayload: payload,
-                )
+                        candidateMessageIDs: Self.messageIDCandidates(from: payload.root?.messageID ?? summary.rootMessageID)
-                for message in descendantMessages {
+                    )
-                    messagesByID[message.id] = message
+                    for message in descendantMessages {
+                        messagesByID[message.id] = message
+                    }
+                } catch {
+                    hadPartialReplyFailure = true
+                    inboxLogger.error(
+                        "Inbox thread descendants failed for \(self.summary.debugIdentifierSummary, privacy: .public): \(error.localizedDescription, privacy: .public)"
+                    )
                 }
             }
                 messageCount: max(messages.count, summary.messageCount ?? 0),
                 messages: messages
             )
+            if hadPartialReplyFailure {
+                partialWarning = "Some replies could not be loaded."
+            }
         } catch {
-            thread = nil
+            if thread == nil {
-            self.error = error.localizedDescription
+                self.error = "Failed to load thread"
+            } else {
+                self.error = error.localizedDescription
+            }
             inboxLogger.error("Inbox thread detail failed for \(self.summary.debugIdentifierSummary, privacy: .public): \(error.localizedDescription, privacy: .public)")
         }
     }
                 variables["cursor"] = threadCursor
             }
-            let response: InboxThreadDetailResponse = try await Self.executeGraphQLRequest(
+            let response: InboxThreadDetailResponse
-                client: client,
+            do {
-                query: Self.threadDetailQuery,
+                response = try await Self.executeGraphQLRequest(
-                variables: {
+                    client: client,
-                    var variables = variables
+                    query: Self.threadDetailQuery,
-                    variables["descCursor"] = nil as String?
+                    variables: {
-                    return variables
+                        var variables = variables
-                }()
+                        variables["descCursor"] = nil as String?
-            )
+                        return variables
+                    }()
+                )
+            } catch {
+                if Self.isRecoverableNoRows(error) {
+                    inboxLogger.error("Inbox thread page scan recoverable miss for \(self.summary.debugIdentifierSummary, privacy: .public): \(error.localizedDescription, privacy: .public)")
+                    return nil
+                }
+                throw error
+            }
             guard let threadPage = response.list?.threads else {
-                throw SRHTError.graphQLErrors([GraphQLError(message: "Thread is no longer available.", locations: nil)])
+                return nil
             }
             let candidates = threadPage.results.map { payload in
         candidateMessageIDs: [String]
     ) async throws -> InboxThreadMessagesPage? {
         for messageID in candidateMessageIDs {
-            let response: InboxThreadLookupResponse = try await Self.executeGraphQLRequest(
+            let response: InboxThreadLookupResponse
-                client: client,
+            do {
-                query: Self.threadByMessageIDQuery,
+                response = try await Self.executeGraphQLRequest(
-                variables: [
+                    client: client,
-                    "rid": summary.listRID,
+                    query: Self.threadByMessageIDQuery,
-                    "messageID": messageID,
+                    variables: [
-                    "descCursor": cursor
+                        "rid": summary.listRID,
-                ]
+                        "messageID": messageID,
-            )
+                        "descCursor": cursor
+                    ]
+                )
+            } catch {
+                if Self.isRecoverableNoRows(error) {
+                    inboxLogger.error(
+                        "Inbox descendant page recoverable miss: thread=\(self.summary.debugIdentifierSummary, privacy: .public) messageID=\(messageID, privacy: .public) error=\(error.localizedDescription, privacy: .public)"
+                    )
+                    continue
+                }
+                throw error
+            }
             if let descendants = response.list?.message?.thread?.descendants {
                 return descendants
     }
     private static func sanitizedDisplayBody(from body: String) -> String {
-        let lines = body.components(separatedBy: .newlines)
+        let normalizedBody = normalizeLineEndings(in: body)
+        let lines = normalizedBody.components(separatedBy: "\n")
         let headerPrefixes = ["From:", "Date:", "To:", "Cc:", "Subject:"]
         var headerCount = 0
         var blankLineIndex: Int?
         }
         guard headerCount >= 2, let blankLineIndex else {
-            return body
+            return stripLeadingFromLineIfPresent(in: normalizedBody)
         }
         return lines.dropFirst(blankLineIndex + 1).joined(separator: "\n")
             .replacingOccurrences(of: "\r", with: "\n")
     }
+    private static func stripLeadingFromLineIfPresent(in body: String) -> String {
+        let lines = body.components(separatedBy: "\n")
+        guard let firstLine = lines.first, firstLine.hasPrefix("From:") else {
+            return body
+        }
+        var remainingLines = Array(lines.dropFirst())
+        if let nextLine = remainingLines.first, nextLine.isEmpty {
+            remainingLines.removeFirst()
+        }
+        return remainingLines.joined(separator: "\n")
+    }
     private static func leadingHeaderValue(named headerName: String, in body: String) -> String? {
         let prefix = "\(headerName):"
         let lines = body.components(separatedBy: .newlines)
         }
         return payload
     }
+    private static func isRecoverableNoRows(_ error: Error) -> Bool {
+        guard case let SRHTError.graphQLErrors(errors) = error else {
+            return false
+        }
+        return errors.allSatisfy { $0.message.localizedCaseInsensitiveContains("no rows in result set") }
+    }
 }

Hutch/Views/Repositories/DiffView.swift +141 −6

	@@ -9,8 +9,73 @@ struct DiffView: View {
9	let diff: String	9	let diff: String
10		10
11	var body: some View {	11	var body: some View {
12	let lines = normalizedDiff.components(separatedBy: "\n")	12	VStack(alignment: .leading, spacing: 12) {
		13	ForEach(fileSections) { section in
		14	DiffFileSectionView(section: section)
		15	}
		16	}
		17	}
		18
		19	private var fileSections: [DiffFileSection] {
		20	DiffFileSection.parse(from: normalizedDiff)
		21	}
13		22
		23	private var normalizedDiff: String {
		24	diff
		25	.replacingOccurrences(of: "\r\n", with: "\n")
		26	.replacingOccurrences(of: "\r", with: "\n")
		27	}
		28	}
		29
		30	private struct DiffFileSectionView: View {
		31	let section: DiffFileSection
		32	@State private var isExpanded = true
		33
		34	var body: some View {
		35	VStack(alignment: .leading, spacing: 0) {
		36	Button {
		37	isExpanded.toggle()
		38	} label: {
		39	HStack(spacing: 10) {
		40	Image(systemName: isExpanded ? "chevron.down" : "chevron.right")
		41	.font(.caption.weight(.semibold))
		42	.foregroundStyle(.secondary)
		43	.frame(width: 12)
		44
		45	Text(section.filename)
		46	.font(.subheadline.weight(.semibold))
		47	.foregroundStyle(.primary)
		48	.lineLimit(1)
		49
		50	Spacer(minLength: 8)
		51
		52	Text(section.changeSummary)
		53	.font(.caption.weight(.medium))
		54	.foregroundStyle(.secondary)
		55	}
		56	.padding(.horizontal, 10)
		57	.padding(.vertical, 8)
		58	.contentShape(Rectangle())
		59	}
		60	.buttonStyle(.plain)
		61	.background(Color(.tertiarySystemBackground))
		62
		63	if isExpanded {
		64	DiffBlockView(lines: section.lines)
		65	}
		66	}
		67	.clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
		68	.overlay {
		69	RoundedRectangle(cornerRadius: 8, style: .continuous)
		70	.strokeBorder(Color.primary.opacity(0.06))
		71	}
		72	}
		73	}
		74
		75	private struct DiffBlockView: View {
		76	let lines: [String]
		77
		78	var body: some View {
14	VStack(alignment: .leading, spacing: 0) {	79	VStack(alignment: .leading, spacing: 0) {
15	ForEach(Array(lines.enumerated()), id: \.offset) { _, line in	80	ForEach(Array(lines.enumerated()), id: \.offset) { _, line in
16	DiffLineView(line: line)	81	DiffLineView(line: line)
	@@ -19,13 +84,83 @@ struct DiffView: View {
19	.font(.system(.caption, design: .monospaced))	84	.font(.system(.caption, design: .monospaced))
20	.frame(maxWidth: .infinity, alignment: .leading)	85	.frame(maxWidth: .infinity, alignment: .leading)
21	.background(Color(.secondarySystemBackground))	86	.background(Color(.secondarySystemBackground))
22	.clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
23	}	87	}
		88	}
24		89
25	private var normalizedDiff: String {	90	private struct DiffFileSection: Identifiable {
26	diff	91	let id: String
27	.replacingOccurrences(of: "\r\n", with: "\n")	92	let filename: String
28	.replacingOccurrences(of: "\r", with: "\n")	93	let lines: [String]
		94	let additions: Int
		95	let deletions: Int
		96
		97	var changeSummary: String {
		98	"+\(additions) -\(deletions)"
		99	}
		100
		101	static func parse(from diff: String) -> [DiffFileSection] {
		102	let lines = diff.components(separatedBy: "\n")
		103	guard !lines.isEmpty else { return [] }
		104
		105	let boundaries = lines.enumerated().compactMap { index, line in
		106	line.hasPrefix("diff --git ") ? index : nil
		107	}
		108
		109	guard !boundaries.isEmpty else {
		110	let section = makeSection(lines: lines, fallbackIndex: 0)
		111	return section.lines.isEmpty ? [] : [section]
		112	}
		113
		114	var sections: [DiffFileSection] = []
		115	for (position, startIndex) in boundaries.enumerated() {
		116	let endIndex = position + 1 < boundaries.count ? boundaries[position + 1] : lines.count
		117	let sectionLines = Array(lines[startIndex..<endIndex])
		118	let section = makeSection(lines: sectionLines, fallbackIndex: position)
		119	if !section.lines.isEmpty {
		120	sections.append(section)
		121	}
		122	}
		123	return sections
		124	}
		125
		126	private static func makeSection(lines: [String], fallbackIndex: Int) -> DiffFileSection {
		127	let filename = fileName(from: lines) ?? "File \(fallbackIndex + 1)"
		128	let additions = lines.filter { $0.hasPrefix("+") && !$0.hasPrefix("+++") }.count
		129	let deletions = lines.filter { $0.hasPrefix("-") && !$0.hasPrefix("---") }.count
		130	return DiffFileSection(
		131	id: "\(fallbackIndex)-\(filename)",
		132	filename: filename,
		133	lines: lines,
		134	additions: additions,
		135	deletions: deletions
		136	)
		137	}
		138
		139	private static func fileName(from lines: [String]) -> String? {
		140	if let diffHeader = lines.first(where: { $0.hasPrefix("diff --git ") }) {
		141	let parts = diffHeader.split(separator: " ")
		142	if let rhs = parts.last, rhs.hasPrefix("b/") {
		143	return String(rhs.dropFirst(2))
		144	}
		145	}
		146
		147	if let plusHeader = lines.first(where: { $0.hasPrefix("+++ ") }) {
		148	let path = String(plusHeader.dropFirst(4))
		149	if path.hasPrefix("b/") {
		150	return String(path.dropFirst(2))
		151	}
		152	return path
		153	}
		154
		155	if let minusHeader = lines.first(where: { $0.hasPrefix("--- ") }) {
		156	let path = String(minusHeader.dropFirst(4))
		157	if path.hasPrefix("a/") {
		158	return String(path.dropFirst(2))
		159	}
		160	return path
		161	}
		162
		163	return nil
29	}	164	}
30	}	165	}
31		166

Hutch/Views/Tickets/TicketDetailView.swift +47 −4

	@@ -132,7 +132,7 @@ struct TicketDetailView: View {
132	ScrollView {	132	ScrollView {
133	VStack(alignment: .leading, spacing: 0) {	133	VStack(alignment: .leading, spacing: 0) {
134	// Header	134	// Header
135	ticketHeader(ticket)	135	ticketHeader(ticket, viewModel: viewModel)
136		136
137	Divider()	137	Divider()
138	.padding(.vertical, 12)	138	.padding(.vertical, 12)
	@@ -186,10 +186,16 @@ struct TicketDetailView: View {
186	// MARK: - Header	186	// MARK: - Header
187		187
188	@ViewBuilder	188	@ViewBuilder
189	private func ticketHeader(_ ticket: TicketDetail) -> some View {	189	private func ticketHeader(_ ticket: TicketDetail, viewModel: TicketDetailViewModel) -> some View {
190	VStack(alignment: .leading, spacing: 8) {	190	VStack(alignment: .leading, spacing: 8) {
191	Text(ticket.title)	191	HStack(alignment: .top, spacing: 12) {
192	.font(.title3.weight(.semibold))	192	Text(ticket.title)
		193	.font(.title3.weight(.semibold))
		194
		195	Spacer(minLength: 12)
		196
		197	assignToMeButton(ticket: ticket, viewModel: viewModel)
		198	}
193		199
194	HStack(spacing: 8) {	200	HStack(spacing: 8) {
195	TicketStatusIcon(status: ticket.status)	201	TicketStatusIcon(status: ticket.status)
	@@ -235,6 +241,43 @@ struct TicketDetailView: View {
235	.padding()	241	.padding()
236	}	242	}
237		243
		244	@ViewBuilder
		245	private func assignToMeButton(ticket: TicketDetail, viewModel: TicketDetailViewModel) -> some View {
		246	if let currentUser = appState.currentUser {
		247	let isAssignedToCurrentUser = ticket.assignees.contains {
		248	TicketDetailViewModel.matchesAssignee($0, user: currentUser)
		249	}
		250
		251	if isAssignedToCurrentUser {
		252	Label("Assigned to you", systemImage: "checkmark.circle.fill")
		253	.font(.caption.weight(.medium))
		254	.foregroundStyle(.secondary)
		255	.padding(.horizontal, 10)
		256	.padding(.vertical, 6)
		257	.background(Color(.secondarySystemFill), in: Capsule())
		258	} else {
		259	Button {
		260	Task {
		261	await viewModel.assignToCurrentUser(currentUser)
		262	}
		263	} label: {
		264	if viewModel.isPerformingAction {
		265	ProgressView()
		266	.controlSize(.small)
		267	.frame(minWidth: 88)
		268	} else {
		269	Text("Assign to Me")
		270	.font(.caption.weight(.semibold))
		271	.frame(minWidth: 88)
		272	}
		273	}
		274	.buttonStyle(.borderedProminent)
		275	.controlSize(.small)
		276	.disabled(viewModel.isPerformingAction)
		277	}
		278	}
		279	}
		280
238	// MARK: - Comment Input	281	// MARK: - Comment Input
239		282
240	@ViewBuilder	283	@ViewBuilder

Hutch/Views/Tickets/TicketDetailViewModel.swift +80

	@@ -433,6 +433,64 @@ final class TicketDetailViewModel {
433	isPerformingAction = false	433	isPerformingAction = false
434	}	434	}
435		435
		436	func assignToCurrentUser(_ user: User) async {
		437	guard !isPerformingAction, let currentTicket = ticket else { return }
		438
		439	let currentAssignees = currentTicket.assignees
		440	let currentEntity = Entity(canonicalName: user.canonicalName)
		441	guard !currentAssignees.contains(where: { Self.matchesAssignee($0, user: user) }) else {
		442	return
		443	}
		444
		445	isPerformingAction = true
		446	error = nil
		447
		448	ticket = TicketDetail(
		449	id: currentTicket.id,
		450	created: currentTicket.created,
		451	updated: currentTicket.updated,
		452	title: currentTicket.title,
		453	description: currentTicket.description,
		454	status: currentTicket.status,
		455	resolution: currentTicket.resolution,
		456	authenticity: currentTicket.authenticity,
		457	submitter: currentTicket.submitter,
		458	assignees: currentAssignees + [currentEntity],
		459	labels: currentTicket.labels
		460	)
		461
		462	do {
		463	_ = try await client.execute(
		464	service: .todo,
		465	query: Self.assignUserMutation,
		466	variables: [
		467	"trackerId": trackerId,
		468	"ticketId": ticketId,
		469	"userId": user.id
		470	],
		471	responseType: AssignUserResponse.self
		472	)
		473	await loadTicket()
		474	} catch {
		475	ticket = TicketDetail(
		476	id: currentTicket.id,
		477	created: currentTicket.created,
		478	updated: currentTicket.updated,
		479	title: currentTicket.title,
		480	description: currentTicket.description,
		481	status: currentTicket.status,
		482	resolution: currentTicket.resolution,
		483	authenticity: currentTicket.authenticity,
		484	submitter: currentTicket.submitter,
		485	assignees: currentAssignees,
		486	labels: currentTicket.labels
		487	)
		488	self.error = error.localizedDescription
		489	}
		490
		491	isPerformingAction = false
		492	}
		493
436	func unassignUser(username: String) async {	494	func unassignUser(username: String) async {
437	guard !isPerformingAction else { return }	495	guard !isPerformingAction else { return }
438	isPerformingAction = true	496	isPerformingAction = true
	@@ -558,4 +616,26 @@ final class TicketDetailViewModel {
558	isPerformingAction = false	616	isPerformingAction = false
559	}	617	}
560		618
		619	static func matchesAssignee(_ entity: Entity, user: User) -> Bool {
		620	let assigneeCanonical = normalizedCanonicalName(entity.canonicalName)
		621	let userCanonical = normalizedCanonicalName(user.canonicalName)
		622	if assigneeCanonical == userCanonical {
		623	return true
		624	}
		625	return normalizedUsername(entity.canonicalName) == normalizedUsername(user.username)
		626	}
		627
		628	private static func normalizedCanonicalName(_ value: String) -> String {
		629	let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
		630	if trimmed.hasPrefix("~") {
		631	return trimmed
		632	}
		633	return "~\(trimmed)"
		634	}
		635
		636	private static func normalizedUsername(_ value: String) -> String {
		637	let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
		638	return trimmed.hasPrefix("~") ? String(trimmed.dropFirst()) : trimmed
		639	}
		640
561	}	641	}

Commit 4c312827dd

Commit `4c312827dd`