Commit `e55d2e00ca`

e55d2e00ca345d84a0fd600eea27dcae42ceecc0

parent: 98784709d7

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-14 08:43 UTC

Admin accounts: no crash on a large cap; deletes and limits say what happened

A storage cap too large for bytes is refused instead of overflowing.
A delete whose retry finds the account gone is reported done, and a
failed limits read says why where the limits would be. New accounts'
addresses start unverified, the delete footer names what blocks it, and
a pending self-deletion shows as a date.

Ref #36

Layout: unified · split

gitbay/Admin/AdminAccount.swift +31 −5

                 return true
             }
             guard let n = Int64(text), n >= 0 else { return false }
-            flags += [flag, String(n * scale)]
+            let (scaled, overflow) = n.multipliedReportingOverflow(by: scale)
+            guard !overflow else { return false }
+            flags += [flag, String(scaled)]
             return true
         }
         guard add("--repos", repos), add("--bytes", megabytes, scale: 1_000_000) else { return nil }
     nonisolated struct Loaded: Sendable, Hashable {
         let detail: AdminAccountDetail
         let limits: OwnerLimits?
+        /// Why the caps could not be read, when they could not.
+        let limitsError: String?
     }
     private(set) var state: LoadState<Loaded> = .loading
         do {
             async let detail = client.read(["admin", "user", "show", username], as: AdminAccountDetail.self)
             // Not a read-only command (it also sets caps), so it goes as a
-            // command even to read; with no flags it changes nothing.
+            // command even to read; with no flags it changes nothing. A
-            async let limits = try? client.run(["admin", "user", "limits", username], as: OwnerLimits.self)
+            // failed read says why under the account, not as its absence.
-            state = .loaded(Loaded(detail: try await detail, limits: await limits))
+            async let limits = readLimits()
+            let (caps, why) = await limits
+            state = .loaded(Loaded(detail: try await detail, limits: caps, limitsError: why))
         } catch {
             state = .from(error)
         }
     }
+    private func readLimits() async -> (OwnerLimits?, String?) {
+        do {
+            return (try await client.run(["admin", "user", "limits", username], as: OwnerLimits.self), nil)
+        } catch let error as GitbayError {
+            return (nil, error.userFacingMessage)
+        } catch {
+            return (nil, GitbayError.transport(error).userFacingMessage)
+        }
+    }
     /// Returns whether the caps changed; a field that is not a number or
     /// `default` is refused here, before the server is asked.
     func setLimits(repos: String, megabytes: String, orgs: String) async -> Bool {
     /// `admin user delete <username> --yes`, for an account that anchors
     /// nothing; the server's refusal names what it still holds.
     func delete() async -> Bool {
-        await perform(["admin", "user", "delete", username, "--yes"], reload: false)
+        if await perform(["admin", "user", "delete", username, "--yes"], reload: false) { return true }
+        // A failure is retried once; a delete that went through and then
+        // failed answers the retry with not found, and the account is gone.
+        return notFoundOnRetry
     }
+    private var notFoundOnRetry = false
     private func perform(_ argv: [String], reload: Bool = true) async -> Bool {
         working = true
         actionError = nil
         defer { working = false }
+        notFoundOnRetry = false
         do {
             try await client.run(argv)
+        } catch GitbayError.notFound(let message) where argv.contains("delete") {
+            notFoundOnRetry = true
+            actionError = message
+            return false
         } catch let error as GitbayError {
             actionError = error.messageForTypedInput
             return false

gitbay/Views/Admin/AdminAccountView.swift +8 −3

                 }
             } else if let loaded = model.state.value {
                 header(loaded.detail)
-                if let limits = loaded.limits { limitsSection(limits) }
+                if let limits = loaded.limits {
+                    limitsSection(limits)
+                } else if let why = loaded.limitsError {
+                    Section("Limits") { GBNotice(why, .gbWarn) }
+                }
                 keysSection(loaded.detail)
                 emailsSection(loaded.detail)
                 if !loaded.detail.orgs.isEmpty { orgsSection(loaded.detail) }
                     .disabled(model.working)
                     .accessibilityIdentifier("admin-account-delete")
                 } footer: {
-                    Text("Only an account that anchors nothing: no repositories, organizations or authored threads. The refusal names what it still holds.")
+                    Text("Only an account that anchors nothing: no repositories, no organization it is the only admin of, and no issues, comments or reviews. The refusal names what it still holds.")
                 }
             }
         }
             LabeledContent("Repositories", value: String(d.repos))
             LabeledContent("Web sessions", value: String(d.webSessions))
             if let after = d.deleteAfter {
-                LabeledContent("Deletes after", value: after)
+                LabeledContent("Deletes after", value: (try? Date(after, strategy: .iso8601))
+                    .map { $0.formatted(date: .abbreviated, time: .shortened) } ?? after)
                     .foregroundStyle(Color.gbBad)
             }
         }

gitbay/Views/Admin/AdminUsersView.swift +2 −1

	@@ -183,7 +183,8 @@ private struct CreateAccountSheet: View {
183		183
184	@State private var username = ""	184	@State private var username = ""
185	@State private var email = ""	185	@State private var email = ""
186	@State private var verified = true	186	/// Off: a mistyped address marked verified would take sign-in links.
		187	@State private var verified = false
187	@State private var admin = false	188	@State private var admin = false
188	@State private var key = ""	189	@State private var key = ""
189	@State private var sent = false	190	@State private var sent = false

gitbayTests/AdminAccountTests.swift +23

	@@ -67,6 +67,8 @@ struct AdminAccountTests {
67	#expect(OwnerLimits.flags(repos: "x", megabytes: "", orgs: nil) == nil)	67	#expect(OwnerLimits.flags(repos: "x", megabytes: "", orgs: nil) == nil)
68	#expect(OwnerLimits.flags(repos: "-1", megabytes: "", orgs: nil) == nil)	68	#expect(OwnerLimits.flags(repos: "-1", megabytes: "", orgs: nil) == nil)
69	#expect(OwnerLimits.flags(repos: "", megabytes: "", orgs: "") == [])	69	#expect(OwnerLimits.flags(repos: "", megabytes: "", orgs: "") == [])
		70	// A cap too large to hold in bytes is refused, not a crash.
		71	#expect(OwnerLimits.flags(repos: "", megabytes: "10000000000000", orgs: nil) == nil)
70	}	72	}
71		73
72	@Test func settingLimitsSendsTheChangedCaps() async throws {	74	@Test func settingLimitsSendsTheChangedCaps() async throws {
	@@ -141,4 +143,25 @@ struct AdminCreateInviteTests {
141	#expect(try posted(stub).map(\.0) == [["admin", "invite", "--email", "fay@example.test"]])	143	#expect(try posted(stub).map(\.0) == [["admin", "invite", "--email", "fay@example.test"]])
142	#expect(note?.contains("abc123") == true)	144	#expect(note?.contains("abc123") == true)
143	}	145	}
		146
		147	@Test func aLimitsReadThatFailsSaysWhy() async throws {
		148	let (client, stub) = try makeClient()
		149	stub.enqueue(.init(status: 200, json: showJSON, match: "argv=show"))
		150	stub.enqueue(.init(status: 403, json: #"{"protocol_version":1,"error":"a read-scoped token cannot run that","exit_code":4}"#, match: "cmd"))
		151	let model = AdminAccountViewModel(client: client, username: "other")
		152
		153	await model.load()
		154
		155	#expect(model.state.value?.limits == nil)
		156	#expect(model.state.value?.limitsError == "a read-scoped token cannot run that")
		157	}
		158
		159	@Test func aDeleteWhoseRetryFindsNothingIsDone() async throws {
		160	let (client, stub) = try makeClient()
		161	stub.enqueue(.init(status: 500, json: #"{"protocol_version":1,"error":"cleanup failed","exit_code":1}"#, match: "cmd"))
		162	stub.enqueue(.init(status: 404, json: #"{"protocol_version":1,"error":"no user \"other\"","exit_code":3}"#, match: "cmd"))
		163	let model = AdminAccountViewModel(client: client, username: "other")
		164
		165	#expect(await model.delete())
		166	}
144	}	167	}

Commit e55d2e00ca

Commit `e55d2e00ca`