Commit `7d4c8f49e2`

7d4c8f49e28dac1eb593a26cf99a2629ebfeaa51

parent: 3f57451dba

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-16 03:26 UTC

Mirrors and domains: expired claims, refresh after a refusal, a record that cannot be lost

An expired claim says so and offers no verify; a refused write reloads the list, so a claim the verify removed goes. The DNS record has copy buttons and its sheet closes only by Done. The sync and verify notices clear on the next action and no longer promise a live list.

Ref #44
Ref #45

Layout: unified · split

gitbay/Repos/RepoMirrorsDomains.swift +10 −1

         } catch {
             actionError = GitbayError.transport(error).userFacingMessage
         }
+        // A refusal may mean the list changed: a claim that expired is
+        // removed by the verify that finds it so.
+        await load()
         return false
     }
 }
 /// One row of `repo domain list`.
 nonisolated struct PageDomain: Decodable, Sendable, Hashable, Identifiable {
     let domain: String
-    /// `pending` until the DNS challenge is verified.
+    /// `pending` until the DNS challenge is verified, `expired` once the
+    /// claim lapsed unverified.
     let state: String
     var verifiedAt: Date? = nil
     var id: String { domain }
     var isVerified: Bool { state == "verified" }
+    /// Waiting on its DNS record; an `expired` claim is neither.
+    var isPending: Bool { state == "pending" }
     enum CodingKeys: String, CodingKey {
         case domain, state
         } catch {
             actionError = GitbayError.transport(error).userFacingMessage
         }
+        // A refusal may mean the list changed: a claim that expired is
+        // removed by the verify that finds it so.
+        await load()
         return false
     }
 }

gitbay/Views/Repos/RepoMirrorDomainViews.swift +58 −22

             if let error = model.actionError, !adding {
                 Section { GBNotice(error, .gbWarn) }
             } else if scheduled {
-                Section { GBNotice("Sync scheduled. The list updates as each mirror finishes.", .gbOK) }
+                Section { GBNotice("Sync scheduled. Pull to refresh for each mirror's result.", .gbOK) }
             }
             Section {
                 ForEach(model.state.value ?? []) { mirror in
                     row(mirror)
                         .swipeActions {
-                            Button("Remove", role: .destructive) { removing = mirror }
+                            Button("Remove", role: .destructive) {
-                                .disabled(model.working)
+                                scheduled = false
+                                removing = mirror
+                            }
+                            .disabled(model.working)
                         }
                 }
             } footer: {
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItem(placement: .topBarTrailing) {
-                Button { adding = true } label: { Image(systemName: "plus") }
+                Button {
+                    scheduled = false
+                    adding = true
+                } label: { Image(systemName: "plus") }
                     .accessibilityLabel("Add Mirror")
                     .disabled(model.working)
                     .accessibilityIdentifier("mirror-add-button")
     @State private var pull = false
     @State private var username = ""
     @State private var token = ""
+    @State private var attempted = false
     var body: some View {
         NavigationStack {
                 } footer: {
                     Text("For a remote that needs credentials. The token is stored for syncs and not shown again.")
                 }
-                if let error = model.actionError {
+                if attempted, let error = model.actionError {
                     Section { GBNotice(error, .gbWarn) }
                 }
             }
                     } else {
                         Button("Add") {
                             Task {
+                                attempted = true
                                 guard await model.add(url: url, pull: pull, username: username, token: token) else { return }
                                 // A secure field that still holds text as the sheet
                                 // goes makes iOS offer to save it as a password.
                     VStack(alignment: .leading, spacing: 3) {
                         Text(claim.domain).font(.gbMono(.subheadline))
                         HStack(spacing: 6) {
-                            GBChip(claim.isVerified ? "verified" : "pending", claim.isVerified ? Color.gbOK : Color.gbWarn)
+                            GBChip(claim.state, claim.isVerified ? Color.gbOK : claim.isPending ? Color.gbWarn : Color.secondary)
                             if let at = claim.verifiedAt {
                                 Text("since \(at.formatted(date: .abbreviated, time: .omitted))")
                                     .font(.gbSans(.caption2))
                     .padding(.vertical, 2)
                     .accessibilityElement(children: .combine)
                     .swipeActions {
-                        Button("Remove", role: .destructive) { removing = claim }
+                        Button("Remove", role: .destructive) {
-                            .disabled(model.working)
+                            verified = nil
-                        if !claim.isVerified {
+                            removing = claim
+                        }
+                        .disabled(model.working)
+                        if claim.isPending {
                             Button("Verify") { verify(claim.domain) }
                                 .tint(.gbAccent)
                                 .disabled(model.working)
                 }
             } footer: {
                 if model.state.value != nil {
-                    Text("A domain serves this repository's pages branch once a DNS TXT record proves the claim. Swipe a pending claim to verify it.")
+                    Text("A domain serves this repository's pages branch once a DNS TXT record proves the claim. Swipe a pending claim to verify it; an expired one has to be claimed again.")
                 }
             }
         }
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItem(placement: .topBarTrailing) {
-                Button { adding = true } label: { Image(systemName: "plus") }
+                Button {
+                    verified = nil
+                    adding = true
+                } label: { Image(systemName: "plus") }
                     .accessibilityLabel("Claim Domain")
                     .disabled(model.working)
                     .accessibilityIdentifier("domain-add-button")
     @State private var domain = ""
     @State private var challenge: DomainChallenge?
+    @State private var attempted = false
     var body: some View {
         NavigationStack {
             Form {
                 if let challenge {
                     Section {
-                        LabeledContent("Name") {
+                        record("Name", challenge.name, id: "domain-copy-name")
-                            Text(challenge.name).font(.gbMono(.caption)).textSelection(.enabled)
-                        }
                         LabeledContent("Type", value: "TXT")
-                        LabeledContent("Value") {
+                        record("Value", challenge.value, id: "domain-copy-value")
-                            Text(challenge.value).font(.gbMono(.caption)).textSelection(.enabled)
-                        }
                     } header: {
                         Text("Create this DNS record")
                     } footer: {
-                        Text("Then verify. An unverified claim expires after a few days; it can also be verified later from the list.")
+                        Text("This record is shown only now. Create it, then verify, here or later from the list. An unverified claim expires after a few days.")
                     }
                 } else {
                     Section {
                         Text("A domain you control. Claiming it gives you a DNS record that proves it.")
                     }
                 }
-                if let error = model.actionError {
+                if attempted, let error = model.actionError {
                     Section { GBNotice(error, .gbWarn) }
                 }
             }
                         ProgressView()
                     } else if let challenge {
                         Button("Verify") {
-                            Task { if await model.verify(challenge.domain) { onDone(challenge.domain) } }
+                            Task {
+                                attempted = true
+                                if await model.verify(challenge.domain) { onDone(challenge.domain) }
+                            }
                         }
                         .accessibilityIdentifier("domain-verify")
                     } else {
                         Button("Claim") {
-                            Task { challenge = await model.add(domain) }
+                            Task {
+                                attempted = true
+                                challenge = await model.add(domain)
+                            }
                         }
                         .disabled(domain.trimmingCharacters(in: .whitespaces).isEmpty)
                         .accessibilityIdentifier("domain-submit")
                     }
                 }
             }
-            .interactiveDismissDisabled(model.working)
+            // The record cannot be fetched again, so it closes only by Done.
+            .interactiveDismissDisabled(model.working || challenge != nil)
+        }
+    }
+    private func record(_ label: String, _ text: String, id: String) -> some View {
+        HStack(alignment: .firstTextBaseline) {
+            VStack(alignment: .leading, spacing: 2) {
+                Text(label).font(.gbSans(.caption)).foregroundStyle(.secondary)
+                Text(text).font(.gbMono(.caption)).textSelection(.enabled)
+            }
+            Spacer()
+            Button {
+                UIPasteboard.general.string = text
+            } label: {
+                Image(systemName: "doc.on.doc")
+            }
+            .buttonStyle(.borderless)
+            .accessibilityLabel("Copy \(label)")
+            .accessibilityIdentifier(id)
         }
     }
 }

gitbayTests/RepoMirrorDomainTests.swift +20 −3

 private let domainsJSON = """
     {"protocol_version":1,"data":[\
     {"domain":"docs.example.test","state":"pending"},\
-    {"domain":"www.example.test","state":"verified","verified_at":"2026-10-01T09:00:00Z"}\
+    {"domain":"www.example.test","state":"verified","verified_at":"2026-10-01T09:00:00Z"},\
+    {"domain":"old.example.test","state":"expired"}\
     ],"exit_code":0}
     """
         await model.load()
         let domains = try #require(model.state.value)
-        #expect(domains.map(\.domain) == ["docs.example.test", "www.example.test"])
+        #expect(domains.map(\.domain) == ["docs.example.test", "www.example.test", "old.example.test"])
-        #expect(!domains[0].isVerified && domains[0].verifiedAt == nil)
+        #expect(domains[0].isPending && domains[0].verifiedAt == nil)
         #expect(domains[1].isVerified && domains[1].verifiedAt != nil)
+        #expect(!domains[2].isPending && !domains[2].isVerified)
     }
     @Test func addReturnsTheDNSChallenge() async throws {
         #expect(model.actionError == #"_gitbay-challenge.docs.example.test does not carry the expected record "x""#)
     }
+    @Test func aRefusedVerifyRefreshesTheList() async throws {
+        let (client, stub) = try makeClient()
+        stub.enqueue(.init(status: 400, json: #"{"protocol_version":1,"error":"the claim on old.example.test expired; run repo domain add again","exit_code":2}"#, match: "cmd"))
+        stub.enqueue(.init(status: 200, json: #"{"protocol_version":1,"data":[],"exit_code":0}"#, match: "argv=list"))
+        let model = PageDomainsViewModel(client: client, repoPath: "krz/gitbay")
+        #expect(await model.verify("old.example.test") == false)
+        #expect(model.actionError == "the claim on old.example.test expired; run repo domain add again")
+        guard case .empty = model.state else {
+            Issue.record("expected the removed claim gone, got \(model.state)")
+            return
+        }
+    }
     @Test func verifyAndRemoveNameTheDomain() async throws {
         let (client, stub) = try makeClient()
         for _ in 0..<2 {

Commit 7d4c8f49e2

Commit `7d4c8f49e2`