Integrate CollabCraft cloud Open/Save/Share/presence

Cargo.toml

@@ -13,7 +13,16 @@ repository = "https://github.com/storytold/pdfcraft"
 
 [workspace.dependencies]
 # Shared frontend components; engines remain independent of egui.
-craft-ui = { git = "https://github.com/storytold/craft-libs", version = "0.1.0", rev = "5c874d51eeb3de70e735c8ce87a59a7dedd47675", features = ["serde"] }
+craft-ui = { git = "https://github.com/wdunn001/craft-libs", version = "0.1.0", rev = "ffdf0556cefc0e7c14ceb32bf4138609702c6f13", features = ["serde", "cloud", "esign"] }
+# Provider-neutral cloud types (Entry, Capability, Permission). Types and contracts only: the
+# crate opens no socket and names no provider, so this builds for the web too.
+craft-cloud = { git = "https://github.com/wdunn001/craft-libs", version = "0.1.0", rev = "3aa7841deee2f9919a4dcca55487db5063293654" }
+craft-esign = { git = "https://github.com/wdunn001/craft-libs", version = "0.1.0", rev = "3aa7841deee2f9919a4dcca55487db5063293654" }
+# How the desktop and browser apps reach CollabCraft. No provider credential or URL compiled in.
+craft-cloud-client = { git = "https://github.com/wdunn001/collab-craft", rev = "23a3b6612eb73a51d54139e25658c94689adbb06" }
+# The share dialog's backend: the half that opens a socket, kept here so only one session lives
+# in the process and a sign-in through Open/Save reaches the share dialog too.
+collabcraft-share = { git = "https://github.com/wdunn001/collab-craft", rev = "23a3b6612eb73a51d54139e25658c94689adbb06" }
 # Quit the macOS way (#1136): ⌘Q asks about unsaved changes, and closing quits through `terminate:`.
 craft-quit = { git = "https://github.com/storytold/craft-libs", version = "0.1.0", rev = "f58bc1a3df490992d633393d0898af0588ce882c" }
 # Shared system spooler; document composition remains in pdfcraft-print.

apps/pdfcraft-web/Cargo.toml

@@ -11,10 +11,17 @@ workspace = true
 
 [dependencies]
 pdfcraft-ui-egui = { workspace = true }
+# Browser transport for Open and Save against CollabCraft. Session rides the cookie; no token file.
+craft-cloud-client = { workspace = true }
+# Share dialog backend for the browser build.
+collabcraft-share = { workspace = true }
 eframe = { workspace = true, features = ["default_fonts", "glow", "persistence", "accesskit"] }
 egui = { workspace = true }
+log = { workspace = true }
+serde_json = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "Location", "Url", "UrlSearchParams", "Response", "Event", "MessageEvent", "EventTarget"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "Location", "Url", "UrlSearchParams", "Response", "Event", "MessageEvent", "EventTarget", "Request", "RequestInit", "RequestCredentials"] }
 js-sys = "0.3"

apps/pdfcraft-web/src/cloud.rs

@@ -0,0 +1,151 @@
+//! CollabCraft transport for the browser build.
+//!
+//! The same jobs and events as the desktop worker ([`pdfcraft::cloud`]), but
+//! the client is async and the session rides the same-origin cookie the service
+//! set at sign-in. There is no device flow and no token file.
+//!
+//! ## Login and logout routing
+//!
+//! When the account check returns Unauthenticated the transport reports the
+//! fault and the title bar shows Sign in. The login popup opens only when the
+//! user clicks Sign in (see [`pdfcraft_ui_egui::web_auth`] and [`pdfcraft_ui_egui::cloud::pump`]).
+//!
+//! A polling closure watches the popup and, when it closes, stores the key
+//! `"pdfcraft:auth_done"` in egui's ephemeral memory and requests a repaint.
+//! The update loop sees the flag, clears it, and calls `sign_in()` to force a
+//! fresh `Job::Account`.
+//!
+//! Sign-out navigates to the service root `/` only after `/auth/logout`
+//! succeeds. Reloading the PDFCraft page on a failed logout would leave the
+//! session cookie active while the user believes they signed out.
+
+use craft_cloud_client::{Client, Error};
+use pdfcraft_ui_egui::cloud::{Account, CloudBackend, Event, Fault, Job, Post};
+use wasm_bindgen::JsCast as _;
+use wasm_bindgen_futures::spawn_local;
+
+/// Hands cloud jobs to async tasks. Cheap to clone.
+#[derive(Clone)]
+pub struct Service {
+    client: Client,
+    ctx: egui::Context,
+}
+
+impl Service {
+    /// Always available when the app is served by CollabCraft on the same
+    /// origin. The page names the service; nothing is compiled in.
+    pub fn new(ctx: egui::Context) -> Service {
+        log::info!("cloud storage through {}", Client::from_page().base());
+        Service { client: Client::from_page(), ctx }
+    }
+}
+
+impl CloudBackend for Service {
+    fn submit(&self, job: Job, post: Post) {
+        let worker = self.clone();
+        spawn_local(async move {
+            worker.run(job, post).await;
+        });
+    }
+}
+
+impl Service {
+    async fn run(self, job: Job, post: Post) {
+        let post = |event: Event| {
+            post.send(event);
+            self.ctx.request_repaint();
+        };
+        match job {
+            Job::Account => {
+                let answer =
+                    self.me().await.map(|me| Account { display: me.display, capabilities: me.capabilities, provider_linked: me.provider_linked });
+                post(Event::Account(answer));
+            }
+            Job::LinkStart => match self.client.link_start().await.map_err(fault) {
+                Ok(start) => post(Event::Browser { url: start.login_url, handle: Some(start.handle) }),
+                Err(f) => post(Event::Linked(Err(f))),
+            },
+            Job::LinkPoll(handle) => {
+                let answer = self.client.link_poll(&handle).await.map_err(fault);
+                post(Event::Linked(answer));
+            }
+            Job::SignOut => {
+                if let Err(e) = fetch_logout().await {
+                    log::warn!("sign-out failed: {e}");
+                    post(Event::Account(Err(Fault::Refused(format!("Sign-out failed: {e}")))));
+                    return;
+                }
+                if let Some(window) = web_sys::window() {
+                    let _ = window.location().assign("/");
+                }
+            }
+            Job::List(path) => {
+                let entries = self.client.list(&path).await.map_err(fault);
+                post(Event::Listed { path, entries });
+            }
+            Job::SharedWithMe => {
+                let answer = self.client.shared_with_me().await.map_err(fault);
+                post(Event::Shared(answer));
+            }
+            Job::Read { entry, into } => {
+                let id = entry.id.clone();
+                let bytes = self.client.read(&id).await.map_err(fault);
+                post(Event::Read { entry, into, bytes });
+            }
+            Job::Write { uid, entry, bytes } => {
+                let id = entry.id.clone();
+                let etag = entry.etag.clone();
+                let answer = self.client.write(&id, &bytes, etag.as_deref()).await.map_err(fault);
+                post(Event::Saved { uid, entry: answer });
+            }
+            Job::Create { uid, folder, name, bytes } => {
+                let answer = self.client.create(&folder, &name, &bytes).await.map_err(fault);
+                post(Event::Saved { uid, entry: answer });
+            }
+            Job::Conversation(id) => {
+                let answer = self.client.conversation(&id).await.map_err(fault);
+                post(Event::Conversation(answer));
+            }
+        }
+    }
+
+    async fn me(&self) -> Result<craft_cloud_client::Me, Fault> {
+        self.client.me().await.map_err(fault)
+    }
+}
+
+fn fault(e: Error) -> Fault {
+    match e {
+        Error::Unauthenticated => Fault::Unauthenticated,
+        Error::NotLinked => Fault::NotLinked,
+        Error::Unreachable(detail) => Fault::Unreachable(detail),
+        Error::Refused { code, .. } if code == "conflict" || code == "409" || code == "412" => Fault::Conflict,
+        Error::Refused { code, detail } => Fault::Refused(if detail.trim().is_empty() { code } else { detail }),
+        Error::Malformed(detail) => Fault::Refused(format!("the cloud service gave an answer PdfCraft could not read: {detail}")),
+        Error::Unsendable(detail) => {
+            log::error!("cloud request could not be encoded: {detail}");
+            Fault::Refused("PdfCraft could not build that request".to_owned())
+        }
+    }
+}
+
+async fn fetch_logout() -> Result<(), String> {
+    let global = js_sys::global();
+    let fetch = js_sys::Reflect::get(&global, &wasm_bindgen::JsValue::from_str("fetch"))
+        .ok()
+        .and_then(|v| v.dyn_into::<js_sys::Function>().ok())
+        .ok_or_else(|| "no fetch".to_owned())?;
+    let init = web_sys::RequestInit::new();
+    init.set_method("POST");
+    init.set_credentials(web_sys::RequestCredentials::Include);
+    let req = web_sys::Request::new_with_str_and_init("/auth/logout", &init).map_err(|e| format!("{e:?}"))?;
+    let promised = fetch.call1(global.as_ref(), req.as_ref()).map_err(|e| format!("{e:?}"))?;
+    let promised: js_sys::Promise = promised.dyn_into().map_err(|_| "not a promise".to_owned())?;
+    let resp = wasm_bindgen_futures::JsFuture::from(promised).await.map_err(|e| format!("{e:?}"))?;
+    let resp: web_sys::Response = resp.dyn_into().map_err(|_| "not a response".to_owned())?;
+    if resp.ok() {
+        Ok(())
+    } else {
+        Err(format!("HTTP {}", resp.status()))
+    }
+}

apps/pdfcraft-web/src/main.rs

@@ -3,6 +3,9 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+#[cfg(target_arch = "wasm32")]
+mod cloud;
+
 #[cfg(target_arch = "wasm32")]
 fn main() {
     use eframe::wasm_bindgen::JsCast;
@@ -17,18 +20,31 @@ fn main() {
         else {
             return;
         };
+        let mut invite = match craft_cloud_client::invite::arrive().await {
+            craft_cloud_client::invite::Arrival::Ordinary => None,
+            craft_cloud_client::invite::Arrival::Refused(reason) => {
+                craft_cloud_client::invite::refuse(&reason);
+                return;
+            }
+            craft_cloud_client::invite::Arrival::Invited(invitation) => Some(invitation),
+        };
         let started = eframe::WebRunner::new()
             .start(
                 canvas,
                 options,
-                Box::new(|cc| {
+                Box::new(move |cc| {
                     let mut app = PdfCraftApp::new();
+                    let invited = invite.is_some();
                     // "printcraft": settings saved under the app's former name, PrintCraft.
-                    if let Some(json) = cc.storage.and_then(|s| s.get_string("pdfcraft").or_else(|| s.get_string("printcraft"))) {
+                    if !invited
+                        && let Some(json) = cc.storage.and_then(|s| s.get_string("pdfcraft").or_else(|| s.get_string("printcraft")))
+                    {
                         app.restore(&json);
                     }
                     // `?file=<url>` opens a PDF from a URL (same-origin or CORS-enabled).
-                    if let Some(url) = query_param("file") {
+                    if !invited
+                        && let Some(url) = query_param("file")
+                    {
                         let inbox = app.startup_inbox.clone();
                         let failed = app.failed_inbox.clone();
                         let ctx = cc.egui_ctx.clone();
@@ -75,6 +91,17 @@ fn main() {
                             &"PdfCraft: ?host=parent needs a framing page on the same origin; saves download instead".into(),
                         );
                     }
+                    // Open and Save against cloud storage. In the browser the session rides
+                    // the same-origin cookie; there is no device flow and no token file.
+                    // `Client::from_page` reads the service URL from the page; on a plain
+                    // deployment it is absent and the interface shows the link-account prompt.
+                    app.cloud.connect(cloud::Service::new(cc.egui_ctx.clone()));
+                    if let Some(share) = collabcraft_share::CollabCraft::from_env() {
+                        app.share.connect(share.for_app("pdfcraft"));
+                    }
+                    if let Some(invitation) = invite.take() {
+                        open_invite(&mut app, invitation);
+                    }
                     Ok(Box::new(app))
                 }),
             )
@@ -90,6 +117,28 @@ fn main() {
     });
 }
 
+#[cfg(target_arch = "wasm32")]
+fn open_invite(app: &mut pdfcraft_ui_egui::PdfCraftApp, invitation: craft_cloud_client::invite::Invitation) {
+    let name = invitation.name.clone();
+    match pdfcraft_ui_egui::cloud::CloudApp::open_bytes(app, &name, invitation.document.clone()) {
+        Ok(Some(_)) => {
+            let mode = if invitation.read_only() { " (view only)" } else { "" };
+            let who = if invitation.recipient.is_empty() { String::new() } else { format!(" (shared with {})", invitation.recipient) };
+            app.cloud.status = Some(format!("Opened \"{name}\"{mode}{who}"));
+            if let Err(e) = invitation.join() {
+                eframe::web_sys::console::warn_1(&format!("invite relay join failed: {e}").into());
+            }
+        }
+        Ok(None) => {
+            app.cloud.status = Some(format!("Shared \"{name}\" needs a choice before it opens"));
+        }
+        Err(e) => {
+            eframe::web_sys::console::error_1(&format!("invite open failed: {e}").into());
+            craft_cloud_client::invite::refuse(&format!("The shared document could not be opened. {e}"));
+        }
+    }
+}
+
 #[cfg(target_arch = "wasm32")]
 fn warn_before_unload(unsaved: std::sync::Arc<std::sync::atomic::AtomicBool>) {
     use eframe::wasm_bindgen::{JsCast, closure::Closure};

apps/pdfcraft/Cargo.toml

@@ -14,6 +14,12 @@ workspace = true
 ureq = { version = "3.4", default-features = false, features = ["rustls-no-provider", "_ring"] }
 rustls-native-certs = "0.8"
 pdfcraft-ui-egui = { workspace = true }
+# How this application reaches CollabCraft. No provider credential, provider URL or provider
+# protocol live here. The service is read from the environment; nothing is compiled in.
+craft-cloud-client = { workspace = true }
+# The share dialog's backend: the half that opens a socket. Kept here so only one session exists
+# per process and a sign-in through Open/Save also reaches the share dialog.
+collabcraft-share = { workspace = true }
 # `build_info`: the version and compile-time build label for `--version` and the log.
 pdfcraft-engine = { workspace = true }
 # wgpu draws; OpenGL (glow) is the fallback when wgpu can't start on an old or unusual GPU or