fix(zbugs): take the ws:// zero-cache address the backend prints (#176)

zbugs' backend prints zero-cache as ws://127.0.0.1:4848, and the clients
only take http:// and https://. zbugs-swift and zbugs-gpui crashed on it,
as on any address the client refused, and zbugs-rune stayed in Error.

Each app now maps ws:// to http:// and wss:// to https:// before it makes
the client. An address with another scheme, or no host, runs the client
offline and says why: zbugs-swift with a warning over the list, and in the
Servers sheet, whose Save it disables; zbugs-gpui with a notification, and
by refusing it in Servers; zbugs-rune in its Servers sheet and in the
connection badge.

Amp-Thread-ID: https://ampcode.com/threads/T-744fb220-85d0-410a-b6e5-d39a2e621de5

Co-authored-by: Amp <amp@ampcode.com>

Author: tmm

apps/zbugs-gpui/src/app.rs

@@ -474,6 +474,9 @@ impl ZbugsApp {
             let q = USER_PREF.call(&SKIN_TONE_PREF.to_owned(), Some(a));
             Live::new(&session.zero, q, &ttl(), cx)
         });
+        // A zero-cache address the client can't take, from the environment
+        // or the saved file: the client runs offline (`Session::new`).
+        let error = zbugs_model::cache_http_url(&session.cache_url).err();
         let mut app = ZbugsApp {
             session,
             filters,
@@ -500,7 +503,7 @@ impl ZbugsApp {
             comment,
             scroll: UniformListScrollHandle::new(),
             connection,
-            error: None,
+            error,
             view_timer: None,
             title: String::new(),
             seen: None,
@@ -569,6 +572,11 @@ impl ZbugsApp {
             cx.notify();
             return false;
         }
+        if let Err(e) = zbugs_model::cache_http_url(&cache_url) {
+            self.error = Some(e);
+            cx.notify();
+            return false;
+        }
         save_setting("cache-url", Some(&cache_url));
         save_setting("api-url", Some(&api_url));
         let token = self.session.token.clone();

apps/zbugs-gpui/src/session.rs

@@ -102,7 +102,9 @@ impl Session {
             auth.clone(),
             client_mutators(),
             ZeroOptions {
-                cache_url: Some(cache_url.clone()),
+                // A bad address, from the environment or the saved file,
+                // runs offline: the app shows why (`ZbugsApp::new`).
+                cache_url: zbugs_model::cache_http_url(&cache_url).ok(),
                 user_id: auth.as_ref().map(|a| a.sub.clone()),
                 auth: token.clone(),
                 mutate_url: Some(format!("{api_url}/api/mutate")),

apps/zbugs-model/src/lib.rs

@@ -17,3 +17,47 @@ pub mod schema;
 pub use auth::{AuthData, make_id};
 pub use mutators::{Context, MutateRequest, client_mutators};
 pub use queries::ZERO_PROJECT_NAME;
+
+/// The zero-cache address as the client takes it. zbugs' backend prints it
+/// as `ws://`, and the client only takes `http://` and `https://`, so `ws://`
+/// becomes `http://` and `wss://` becomes `https://`. Any other scheme, or
+/// no host, is an error to show.
+pub fn cache_http_url(url: &str) -> Result<String, String> {
+    let url = url.trim();
+    let (scheme, rest) = url.split_once("://").unwrap_or(("", ""));
+    let scheme = match scheme.to_ascii_lowercase().as_str() {
+        "http" | "ws" => "http",
+        "https" | "wss" => "https",
+        _ => "",
+    };
+    if scheme.is_empty() || rest.is_empty() || rest.starts_with(['/', '?', '#']) {
+        return Err(format!(
+            "{url:?} isn't a zero-cache address. Use an http://, https://, ws://, or wss:// URL, such as http://127.0.0.1:4848."
+        ));
+    }
+    Ok(format!("{scheme}://{rest}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::cache_http_url;
+
+    #[test]
+    fn cache_http_url_takes_websocket_schemes() {
+        let ok = |u: &str| cache_http_url(u).unwrap();
+        assert_eq!(ok("ws://127.0.0.1:4848"), "http://127.0.0.1:4848");
+        assert_eq!(ok(" WSS://zero.example/x "), "https://zero.example/x");
+        assert_eq!(ok("http://h:1/p"), "http://h:1/p");
+        assert_eq!(ok("https://h"), "https://h");
+        for bad in [
+            "",
+            "127.0.0.1:4848",
+            "ftp://h",
+            "ws://",
+            "http:///p",
+            "wsx://h",
+        ] {
+            assert!(cache_http_url(bad).is_err(), "{bad}");
+        }
+    }
+}

apps/zbugs-rune/src/main.rs

@@ -339,8 +339,12 @@ impl App {
             self.settings.token = None;
         }
         self.me = None;
+        // A bad address, from the environment or the saved settings, fails
+        // the client, and the connection badge says why.
+        let cache_url = zbugs_model::cache_http_url(&self.settings.cache_url)
+            .unwrap_or_else(|_| self.settings.cache_url.clone());
         self.sync.connect(Session {
-            cache_url: self.settings.cache_url.clone(),
+            cache_url,
             api_url: self.settings.api_url.clone(),
             token: self.settings.token.clone(),
             user_id: self.auth.as_ref().map(|a| a.sub.clone()),
@@ -1088,8 +1092,12 @@ impl App {
     pub fn save_servers(&mut self) {
         let cache = self.cache_edit.text.trim().trim_end_matches('/').to_owned();
         let api = self.api_edit.text.trim().trim_end_matches('/').to_owned();
-        if !cache.starts_with("http") || !api.starts_with("http") {
-            self.sheet_error = Some("Both are http:// or https:// URLs.".into());
+        if let Err(e) = zbugs_model::cache_http_url(&cache) {
+            self.sheet_error = Some(e);
+            return;
+        }
+        if !api.starts_with("http") {
+            self.sheet_error = Some("The zbugs API is an http:// or https:// URL.".into());
             return;
         }
         self.settings.cache_url = cache.clone();

apps/zbugs-rune/src/sync.rs

@@ -255,7 +255,8 @@ impl<S: 'static, C: Clone + 'static> Worker<S, C> {
         ) {
             Ok(z) => z,
             Err(e) => {
-                // Only a mutator registered twice fails here.
+                // A mutator registered twice, or a cache URL that isn't
+                // http:// or https://, fails here.
                 let reason = e.message();
                 let f = self.on_connection;
                 self.ui

apps/zbugs-swift/Sources/ZBugs/CacheURL.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+/// The zero-cache address as the client takes it. zbugs' backend prints it
+/// as `ws://`, and the client only takes `http://` and `https://`, so `ws://`
+/// becomes `http://` and `wss://` becomes `https://`. Nil for any other
+/// scheme, or no host: `cacheURLError` says why.
+public func cacheClientURL(_ url: String) -> String? {
+  let url = url.trimmingCharacters(in: .whitespacesAndNewlines)
+  guard let separator = url.range(of: "://") else { return nil }
+  let rest = url[separator.upperBound...]
+  guard let first = rest.first, !"/?#".contains(first) else { return nil }
+  switch url[..<separator.lowerBound].lowercased() {
+  case "http", "ws": return "http://" + rest
+  case "https", "wss": return "https://" + rest
+  default: return nil
+  }
+}
+
+/// Why the client can't take `url` as the zero-cache address, or nil when it
+/// can.
+public func cacheURLError(_ url: String) -> String? {
+  cacheClientURL(url) == nil
+    ? "\"\(url)\" isn't a zero-cache address. Use an http://, https://, ws://, or wss:// URL, such as http://127.0.0.1:4848."
+    : nil
+}

apps/zbugs-swift/Sources/ZBugsUI/AppModel.swift

@@ -77,6 +77,10 @@
       restart()
     }
 
+    /// Why the zero-cache address doesn't work, for a warning; the client
+    /// runs offline until it's fixed.
+    public var cacheURLError: String? { ZBugs.cacheURLError(cacheURL) }
+
     /// Whether a server is set to this device itself, where the app can't
     /// reach the backend: see `isThisDevice`.
     public var serversAreThisDevice: Bool {
@@ -147,15 +151,18 @@
     private static func makeZero(
       cacheURL: String, apiURL: String, token: String?, auth: AuthData?
     ) -> Zero<AuthData?> {
-      var options = ZeroOptions(cacheURL: cacheURL, userID: auth?.sub, auth: token)
+      // A bad address runs offline, as `cacheURLError` says, rather than
+      // failing the client.
+      var options = ZeroOptions(
+        cacheURL: cacheClientURL(cacheURL), userID: auth?.sub, auth: token)
       options.mutateURL = apiURL + "/api/mutate"
       options.queryURL = apiURL + "/api/query"
       options.logLevel = .info
       do {
         return try Zero(schema: .zbugs, context: auth, mutators: Mutators.all, options: options)
       } catch {
-        // Only a mutator registered twice fails; storage falls back to
-        // memory on its own.
+        // Only a mutator registered twice fails: the cache URL is one it
+        // takes, and storage falls back to memory on its own.
         preconditionFailure("zbugs' mutators: \(error)")
       }
     }

apps/zbugs-swift/Sources/ZBugsUI/RootView.swift

@@ -85,8 +85,10 @@
           .toolbar { toolbar }
           // Otherwise the list only says it's connecting, as it never will.
           .safeAreaInset(edge: .bottom) {
-            if model.serversAreThisDevice && model.zero.connection.state != .connected {
-              ServersWarning { sheet = .servers }
+            if let error = model.cacheURLError {
+              ServersWarning(message: error) { sheet = .servers }
+            } else if model.serversAreThisDevice && model.zero.connection.state != .connected {
+              ServersWarning(message: AppModel.thisDeviceWarning) { sheet = .servers }
             }
           }
       } detail: {
@@ -300,13 +302,14 @@
     }
   }
 
-  /// Servers set to this device, with a way to change them.
+  /// Servers the app can't reach, with a way to change them.
   private struct ServersWarning: View {
+    let message: String
     let change: () -> Void
 
     var body: some View {
       VStack(alignment: .leading, spacing: 8) {
-        SwiftUI.Label(AppModel.thisDeviceWarning, systemImage: "exclamationmark.triangle.fill")
+        SwiftUI.Label(message, systemImage: "exclamationmark.triangle.fill")
           .symbolRenderingMode(.multicolor)
         Button("Servers…", action: change)
           .buttonStyle(.borderedProminent)

apps/zbugs-swift/Sources/ZBugsUI/Sheets.swift

@@ -145,7 +145,10 @@
             TextField("zero-cache", text: $cacheURL)
             TextField("zbugs API", text: $apiURL)
           } footer: {
-            if AppModel.isThisDevice(cacheURL) || AppModel.isThisDevice(apiURL) {
+            if let error = cacheURLError(cacheURL) {
+              Text(error)
+                .foregroundStyle(.red)
+            } else if AppModel.isThisDevice(cacheURL) || AppModel.isThisDevice(apiURL) {
               Text(AppModel.thisDeviceWarning)
                 .foregroundStyle(.orange)
             }
@@ -163,6 +166,7 @@
               model.setServers(cacheURL: cacheURL, apiURL: apiURL)
               dismiss()
             }
+            .disabled(cacheURLError(cacheURL) != nil)
           }
         }
         .onAppear {

apps/zbugs-swift/Tests/ZBugsTests/CacheURLTests.swift

@@ -0,0 +1,19 @@
+import Testing
+import ZBugs
+
+@Suite struct CacheURLTests {
+  @Test func takesWebSocketSchemesAsTheirHTTPOnes() {
+    #expect(cacheClientURL("ws://127.0.0.1:4848") == "http://127.0.0.1:4848")
+    #expect(cacheClientURL(" WSS://zero.example/x ") == "https://zero.example/x")
+    #expect(cacheClientURL("http://h:1/p") == "http://h:1/p")
+    #expect(cacheClientURL("https://h") == "https://h")
+  }
+
+  @Test func rejectsOtherSchemesAndMissingHosts() {
+    for bad in ["", "127.0.0.1:4848", "ftp://h", "ws://", "http:///p", "wsx://h"] {
+      #expect(cacheClientURL(bad) == nil, "\(bad)")
+      #expect(cacheURLError(bad) != nil, "\(bad)")
+    }
+    #expect(cacheURLError("ws://127.0.0.1:4848") == nil)
+  }
+}