@aptre/bldr-saucer 0.2.6 → 0.4.1

package/CMakeLists.txt

@@ -19,6 +19,7 @@ set(saucer_serializer "Glaze" CACHE STRING "" FORCE)
 set(saucer_no_version_check ON CACHE BOOL "" FORCE)
 set(saucer_examples OFF CACHE BOOL "" FORCE)
 set(saucer_tests OFF CACHE BOOL "" FORCE)
+set(saucer_exceptions OFF CACHE BOOL "" FORCE)
 
 # cpp-yamux options.
 set(YAMUX_BUILD_TESTS OFF CACHE BOOL "" FORCE)

package/package.json

@@ -1,24 +1,28 @@
 {
   "name": "@aptre/bldr-saucer",
-  "version": "0.2.6",
+  "version": "0.4.1",
   "description": "Native webview bridge for Bldr using Saucer",
   "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/aperturerobotics/bldr-saucer.git"
-  },
+  "license": "MIT",
   "keywords": [
     "webview",
     "saucer",
     "native",
     "bldr"
   ],
-  "author": "Aptre",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aperturerobotics/bldr-saucer.git"
+  },
   "bugs": {
     "url": "https://github.com/aperturerobotics/bldr-saucer/issues"
   },
   "homepage": "https://github.com/aperturerobotics/bldr-saucer#readme",
+  "author": {
+    "name": "Aperture Robotics LLC.",
+    "email": "support@aperture.us",
+    "url": "http://aperture.us"
+  },
   "scripts": {
     "postinstall": "node install.js",
     "gen": "bun run go:aptre -- generate",
@@ -33,11 +37,11 @@
     "release:publish": "git push && git push --tags"
   },
   "optionalDependencies": {
-    "@aptre/bldr-saucer-darwin-arm64": "0.2.6",
-    "@aptre/bldr-saucer-darwin-x64": "0.2.6",
-    "@aptre/bldr-saucer-linux-x64": "0.2.6",
-    "@aptre/bldr-saucer-linux-arm64": "0.2.6",
-    "@aptre/bldr-saucer-win32-x64": "0.2.6"
+    "@aptre/bldr-saucer-darwin-arm64": "0.4.1",
+    "@aptre/bldr-saucer-darwin-x64": "0.4.1",
+    "@aptre/bldr-saucer-linux-x64": "0.4.1",
+    "@aptre/bldr-saucer-linux-arm64": "0.4.1",
+    "@aptre/bldr-saucer-win32-x64": "0.4.1"
   },
   "files": [
     "index.js",
@@ -46,9 +50,9 @@
     "CMakeLists.txt"
   ],
   "devDependencies": {
-    "@aptre/common": "^0.30.3"
+    "@aptre/common": "^0.32.0"
   },
   "dependencies": {
-    "@aptre/protobuf-es-lite": "^0.5.2"
+    "@aptre/protobuf-es-lite": "^1.0.0"
   }
 }

package/src/main.cpp

@@ -113,16 +113,23 @@ coco::stray start(saucer::application* app) {
     // Register bldr:// scheme BEFORE creating the webview.
     saucer::webview::register_scheme("bldr");
 
+    // Construct a per-instance storage path from the runtime ID.
+    // This ensures concurrent bldr-saucer instances don't share webview storage.
+    auto storage = std::filesystem::temp_directory_path() / ("bldr-saucer-" + runtime_id);
+
     auto window = saucer::window::create(app).value();
-    auto webview = saucer::smartview::create({.window = window});
+    auto webview = saucer::smartview::create({
+        .window = window,
+        .storage_path = storage,
+    });
 
     window->set_title("Bldr");
     window->set_size({1024, 768});
 
     // Handle bldr:// scheme: forward all requests to Go over yamux.
-    webview->handle_stream_scheme("bldr", [forwarder](saucer::scheme::request req, saucer::scheme::stream_writer writer) {
-        std::thread([forwarder, req = std::move(req), writer = std::move(writer)]() mutable {
-            forwarder->forward(req, writer);
+    webview->handle_scheme("bldr", [forwarder](saucer::scheme::request req, saucer::scheme::executor executor) {
+        std::thread([forwarder, req = std::move(req), executor = std::move(executor)]() mutable {
+            forwarder->forward(req, executor);
         }).detach();
     });
 
@@ -157,7 +164,7 @@ coco::stray start(saucer::application* app) {
     // The smartview's own handler returns unhandled for unrecognized messages,
     // so this handler sees them next.
     constexpr std::string_view eval_prefix = "__bldr_eval:";
-    webview->on<saucer::webview::event::message>({{.func = [eval_registry, eval_prefix](std::string_view message) -> saucer::status {
+    webview->on<saucer::webview::event::message>([eval_registry, eval_prefix](std::string_view message) -> saucer::status {
         if (!message.starts_with(eval_prefix)) {
             return saucer::status::unhandled;
         }
@@ -183,7 +190,7 @@ coco::stray start(saucer::application* app) {
             eval_registry->Deliver(eval_id, "", data);
         }
         return saucer::status::handled;
-    }}});
+    });
 
     // Start accept loop for Go-initiated streams (debug eval).
     // webview is a std::expected; use &(*webview) to get a pointer to the contained value.

package/src/scheme_forwarder.cpp

@@ -14,18 +14,42 @@ static std::string toLower(const std::string& s) {
     return out;
 }
 
-// sendError sends an error response to the saucer writer.
-static void sendError(saucer::scheme::stream_writer& writer, int status) {
-    writer.start({.mime = "text/plain", .status = status});
-    writer.finish();
+// corsHeaders are Access-Control headers added to all scheme responses.
+// WebKit treats custom scheme origins as opaque (null), so all fetch requests
+// from pages loaded via bldr:// are cross-origin. These headers allow them.
+static const std::map<std::string, std::string> corsHeaders = {
+    {"Access-Control-Allow-Origin", "*"},
+    {"Access-Control-Allow-Methods", "GET, POST, OPTIONS"},
+    {"Access-Control-Allow-Headers", "*"},
+};
+
+// sendError resolves the executor with an error status response.
+static void sendError(saucer::scheme::executor& executor, int status) {
+    executor.resolve({
+        .data = saucer::stash::empty(),
+        .mime = "text/plain",
+        .headers = corsHeaders,
+        .status = status,
+    });
 }
 
 void SchemeForwarder::forward(const saucer::scheme::request& req,
-                               saucer::scheme::stream_writer& writer) {
+                               saucer::scheme::executor& executor) {
+    // Handle CORS preflight directly without forwarding to Go.
+    if (toLower(req.method()) == "options") {
+        executor.resolve({
+            .data = saucer::stash::empty(),
+            .mime = "text/plain",
+            .headers = corsHeaders,
+            .status = 204,
+        });
+        return;
+    }
+
     // Open a new yamux stream.
     auto [stream, err] = session_->OpenStream();
     if (err != yamux::Error::OK || !stream) {
-        sendError(writer, 502);
+        sendError(executor, 502);
         return;
     }
 
@@ -40,62 +64,68 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
     }
 
     // Check if request has a body.
-    auto content = req.content();
+    auto content = req.content().data();
     info.has_body = (content.size() > 0);
 
     // Serialize and send FetchRequestInfo frame.
     auto reqInfoMsg = proto::EncodeFetchRequest_Info(info);
     if (!writeFrame(stream.get(), reqInfoMsg)) {
         stream->Close();
-        sendError(writer, 502);
+        sendError(executor, 502);
         return;
     }
 
     // Send body if present.
     if (info.has_body) {
         proto::FetchRequestData bodyData;
-        bodyData.data.assign(
-            static_cast<const uint8_t*>(content.data()),
-            static_cast<const uint8_t*>(content.data()) + content.size()
-        );
+        bodyData.data.assign(content.data(), content.data() + content.size());
         bodyData.done = true;
 
         auto reqDataMsg = proto::EncodeFetchRequest_Data(bodyData);
         if (!writeFrame(stream.get(), reqDataMsg)) {
             stream->Close();
-            sendError(writer, 502);
+            sendError(executor, 502);
             return;
         }
     }
 
+    // Create streaming stash for incremental response delivery.
+    auto result = saucer::scheme::response::stream();
+    if (!result) {
+        executor.reject(saucer::scheme::error::failed);
+        stream->Close();
+        return;
+    }
+    auto [stash, write] = std::move(*result);
+
     // Read response frames from Go.
-    bool started = false;
+    bool resolved = false;
     bool done = false;
 
     while (!done) {
         std::vector<uint8_t> frame;
         if (!readFrame(stream.get(), frame)) {
-            if (!started) {
-                sendError(writer, 502);
+            if (!resolved) {
+                executor.reject(saucer::scheme::error::failed);
             }
             break;
         }
 
         proto::FetchResponse resp;
         if (!proto::DecodeFetchResponse(frame.data(), frame.size(), resp)) {
-            if (!started) {
-                sendError(writer, 502);
+            if (!resolved) {
+                executor.reject(saucer::scheme::error::failed);
             }
             break;
         }
 
-        // Process ResponseInfo (first frame).
-        if (resp.has_info && !started) {
-            started = true;
+        // Process ResponseInfo (first frame): resolve executor with headers and streaming stash.
+        if (resp.has_info && !resolved) {
+            resolved = true;
 
-            // Extract Content-Type header (case-insensitive).
+            // Extract Content-Type header (case-insensitive) and merge CORS headers.
             std::string mime = "application/octet-stream";
-            std::map<std::string, std::string> hdrs;
+            std::map<std::string, std::string> hdrs(corsHeaders);
             for (const auto& [key, val] : resp.info.headers) {
                 if (toLower(key) == "content-type") {
                     mime = val;
@@ -104,22 +134,29 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
                 }
             }
 
-            writer.start({
+            executor.resolve({
+                .data = std::move(stash),
                 .mime = mime,
                 .headers = hdrs,
                 .status = static_cast<int>(resp.info.status),
             });
         }
 
-        // Process ResponseData.
+        // Process ResponseData: push body chunks via streaming write callback.
         if (resp.has_data) {
-            if (!started) {
-                started = true;
-                writer.start({.mime = "application/octet-stream", .status = 200});
+            if (!resolved) {
+                resolved = true;
+                executor.resolve({
+                    .data = std::move(stash),
+                    .mime = "application/octet-stream",
+                    .status = 200,
+                });
             }
 
-            if (!resp.data.data.empty() && writer.valid()) {
-                writer.write(saucer::stash::from(std::move(resp.data.data)));
+            if (!resp.data.data.empty()) {
+                if (!write({resp.data.data.data(), resp.data.data.size()})) {
+                    break;
+                }
             }
 
             if (resp.data.done) {
@@ -128,9 +165,7 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
         }
     }
 
-    if (started) {
-        writer.finish();
-    }
+    // Destroying write closes the streaming stash.
     stream->Close();
 }
 

package/src/scheme_forwarder.h

@@ -3,6 +3,7 @@
 #include "fetch_proto.h"
 #include "yamux/session.hpp"
 
+#include <saucer/scheme.hpp>
 #include <saucer/smartview.hpp>
 
 #include <cstdint>
@@ -21,7 +22,7 @@ public:
     explicit SchemeForwarder(yamux::Session* session) : session_(session) {}
 
     // forward handles a single scheme request by forwarding it to Go.
-    void forward(const saucer::scheme::request& req, saucer::scheme::stream_writer& writer);
+    void forward(const saucer::scheme::request& req, saucer::scheme::executor& executor);
 
 private:
     // writeFrame writes a length-prefixed frame to a yamux stream.