@aptre/bldr-saucer 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptre/bldr-saucer",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Native webview bridge for Bldr using Saucer",
   "main": "index.js",
   "repository": {
@@ -33,11 +33,11 @@
     "release:publish": "git push && git push --tags"
   },
   "optionalDependencies": {
-    "@aptre/bldr-saucer-darwin-arm64": "0.2.3",
-    "@aptre/bldr-saucer-darwin-x64": "0.2.3",
-    "@aptre/bldr-saucer-linux-x64": "0.2.3",
-    "@aptre/bldr-saucer-linux-arm64": "0.2.3",
-    "@aptre/bldr-saucer-win32-x64": "0.2.3"
+    "@aptre/bldr-saucer-darwin-arm64": "0.2.5",
+    "@aptre/bldr-saucer-darwin-x64": "0.2.5",
+    "@aptre/bldr-saucer-linux-x64": "0.2.5",
+    "@aptre/bldr-saucer-linux-arm64": "0.2.5",
+    "@aptre/bldr-saucer-win32-x64": "0.2.5"
   },
   "files": [
     "index.js",
@@ -46,7 +46,7 @@
     "CMakeLists.txt"
   ],
   "devDependencies": {
-    "@aptre/common": "^0.30.1"
+    "@aptre/common": "^0.30.3"
   },
   "dependencies": {
     "@aptre/protobuf-es-lite": "^0.5.2"

package/src/main.cpp

@@ -4,15 +4,20 @@
 #include "pipe_connection.h"
 #include "scheme_forwarder.h"
 
+#include <atomic>
 #include <cstdlib>
+#include <cstring>
 #include <iostream>
+#include <memory>
+#include <mutex>
 #include <string>
 #include <thread>
+#include <vector>
 
 coco::stray start(saucer::application* app) {
     const char* runtime_id_env = std::getenv("BLDR_RUNTIME_ID");
     if (!runtime_id_env) {
-        std::cerr << "BLDR_RUNTIME_ID not set" << std::endl;
+        std::cerr << "[bldr-saucer] BLDR_RUNTIME_ID not set" << std::endl;
         co_return;
     }
     std::string runtime_id = runtime_id_env;
@@ -22,7 +27,7 @@ coco::stray start(saucer::application* app) {
     if (init_b64) {
         auto data = bldr::proto::Base64Decode(init_b64);
         if (!data.empty() && !bldr::proto::DecodeSaucerInit(data.data(), data.size(), saucer_init)) {
-            std::cerr << "Failed to decode BLDR_SAUCER_INIT" << std::endl;
+            std::cerr << "[bldr-saucer] failed to decode BLDR_SAUCER_INIT" << std::endl;
         }
     }
 
@@ -30,7 +35,7 @@ coco::stray start(saucer::application* app) {
     bldr::PipeClient pipe;
     std::string pipe_path = ".pipe-" + runtime_id;
     if (!pipe.connect(pipe_path)) {
-        std::cerr << "Failed to connect to pipe: " << pipe_path << std::endl;
+        std::cerr << "[bldr-saucer] failed to connect to pipe: " << pipe_path << std::endl;
         co_return;
     }
 
@@ -41,12 +46,12 @@ coco::stray start(saucer::application* app) {
     config.enable_keepalive = false;
     auto session = yamux::Session::Client(std::move(conn), config);
     if (!session) {
-        std::cerr << "Failed to create yamux session" << std::endl;
+        std::cerr << "[bldr-saucer] failed to create yamux session" << std::endl;
         co_return;
     }
 
-    // Create the scheme forwarder.
-    bldr::SchemeForwarder forwarder(session.get());
+    // Create the scheme forwarder (shared_ptr to avoid use-after-free in detached threads).
+    auto forwarder = std::make_shared<bldr::SchemeForwarder>(session.get());
 
     // Register bldr:// scheme BEFORE creating the webview.
     saucer::webview::register_scheme("bldr");
@@ -58,15 +63,13 @@ coco::stray start(saucer::application* app) {
     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) {
-        // Forward in background thread to not block the scheme handler.
-        std::thread([&forwarder, req = std::move(req), writer = std::move(writer)]() mutable {
-            forwarder.forward(req, writer);
+    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);
         }).detach();
     });
 
-    // Use set_html with JavaScript redirect to work around WebKit's
-    // loadFileURL being called incorrectly for custom schemes.
+    // Navigate via HTML redirect (works around WebKit's loadFileURL issue with custom schemes).
     std::string nav_url = "bldr:///index.html";
     const char* doc_id_env = std::getenv("BLDR_WEB_DOCUMENT_ID");
     if (doc_id_env && doc_id_env[0] != '\0') {
@@ -82,18 +85,96 @@ coco::stray start(saucer::application* app) {
         webview->set_dev_tools(true);
     }
 
+    // Shutdown guard: prevents webview->execute() calls after webview destruction.
+    // The mutex ensures no thread is inside execute() when we set the flag.
+    auto webview_mtx = std::make_shared<std::mutex>();
+    auto webview_alive = std::make_shared<std::atomic<bool>>(true);
+
+    // Start accept loop for Go-initiated streams (debug eval).
+    // webview is a std::expected; use &(*webview) to get a pointer to the contained value.
+    auto* webview_ptr = &(*webview);
+    std::thread accept_thread([session, webview_ptr, webview_mtx, webview_alive]() {
+        while (true) {
+            auto [stream, err] = session->Accept();
+            if (err != yamux::Error::OK || !stream) {
+                break;
+            }
+
+            // Handle each stream in a detached thread so accept loop continues.
+            std::thread([stream, webview_ptr, webview_mtx, webview_alive]() {
+                // Read length-prefixed command frame.
+                uint8_t len_buf[4];
+                size_t total = 0;
+                while (total < 4) {
+                    auto [n, rerr] = stream->Read(len_buf + total, 4 - total);
+                    if (rerr != yamux::Error::OK || n == 0) {
+                        stream->Close();
+                        return;
+                    }
+                    total += n;
+                }
+                uint32_t msg_len;
+                std::memcpy(&msg_len, len_buf, 4);
+                if (msg_len > 10 * 1024 * 1024) {
+                    stream->Close();
+                    return;
+                }
+
+                std::vector<uint8_t> data(msg_len);
+                total = 0;
+                while (total < msg_len) {
+                    auto [n, rerr] = stream->Read(data.data() + total, msg_len - total);
+                    if (rerr != yamux::Error::OK || n == 0) break;
+                    total += n;
+                }
+                if (total < msg_len) {
+                    stream->Close();
+                    return;
+                }
+
+                std::string code(data.begin(), data.end());
+
+                // Execute the JavaScript code in the webview (guarded against shutdown).
+                // Cast to webview* to call webview::execute(cstring_view) instead of
+                // smartview::execute(format_string) which has a consteval constructor
+                // that breaks std::thread lambdas in C++23.
+                {
+                    std::lock_guard<std::mutex> lock(*webview_mtx);
+                    if (webview_alive->load()) {
+                        static_cast<saucer::webview*>(webview_ptr)->execute(code);
+                    }
+                }
+
+                // Write a simple "ok" response.
+                std::string resp = "ok";
+                uint8_t resp_len_buf[4];
+                uint32_t resp_len = static_cast<uint32_t>(resp.size());
+                std::memcpy(resp_len_buf, &resp_len, 4);
+                stream->Write(resp_len_buf, 4);
+                stream->Write(reinterpret_cast<const uint8_t*>(resp.data()), resp.size());
+                stream->Close();
+            }).detach();
+        }
+    });
+    accept_thread.detach();
+
     window->show();
     co_await app->finish();
 
-    // Cleanup.
+    // Shutdown: close session first (causes Accept/Read/Write to return errors,
+    // winding down detached threads), then mark webview as dead.
     session->Close();
+    {
+        std::lock_guard<std::mutex> lock(*webview_mtx);
+        webview_alive->store(false);
+    }
     pipe.close();
 }
 
 int main() {
     auto app_result = saucer::application::create({.id = "bldr"});
     if (!app_result) {
-        std::cerr << "Failed to create application" << std::endl;
+        std::cerr << "[bldr-saucer] failed to create application" << std::endl;
         return 1;
     }
     return app_result->run(start);

package/src/pipe_client.cpp

@@ -20,7 +20,8 @@ PipeClient::~PipeClient() {
 }
 
 bool PipeClient::connect(const std::string& pipe_path) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::mutex> rlock(read_mtx_);
+    std::lock_guard<std::mutex> wlock(write_mtx_);
 
 #ifdef _WIN32
     // Windows named pipe connection
@@ -82,9 +83,22 @@ bool PipeClient::connect(const std::string& pipe_path) {
 }
 
 void PipeClient::close() {
-    std::lock_guard<std::mutex> lock(mutex_);
+    // Set disconnected first so blocked reads/writes return.
     connected_ = false;
 
+#ifndef _WIN32
+    // Shut down the socket to unblock any thread in a blocking read.
+    // This is safe to call without holding locks since shutdown on a
+    // valid fd is thread-safe and causes blocked read/write to return.
+    int fd = fd_;
+    if (fd >= 0) {
+        ::shutdown(fd, SHUT_RDWR);
+    }
+#endif
+
+    std::lock_guard<std::mutex> rlock(read_mtx_);
+    std::lock_guard<std::mutex> wlock(write_mtx_);
+
 #ifdef _WIN32
     if (handle_ != INVALID_HANDLE_VALUE) {
         CloseHandle(handle_);
@@ -107,7 +121,7 @@ std::vector<uint8_t> PipeClient::read() {
 }
 
 std::vector<uint8_t> PipeClient::read_with_timeout(int timeout_ms) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::mutex> lock(read_mtx_);
     std::vector<uint8_t> result;
 
     if (!connected_) {
@@ -186,7 +200,7 @@ std::vector<uint8_t> PipeClient::read_with_timeout(int timeout_ms) {
 }
 
 bool PipeClient::write(const uint8_t* data, size_t length) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::mutex> lock(write_mtx_);
 
     if (!connected_ || data == nullptr || length == 0) {
         return false;

package/src/pipe_client.h

@@ -64,7 +64,8 @@ private:
     int fd_ = -1;
 #endif
     std::atomic<bool> connected_{false};
-    std::mutex mutex_;
+    std::mutex read_mtx_;
+    std::mutex write_mtx_;
 };
 
 } // namespace bldr

package/src/scheme_forwarder.cpp

@@ -3,7 +3,6 @@
 #include <algorithm>
 #include <cctype>
 #include <cstring>
-#include <iostream>
 
 namespace bldr {
 
@@ -26,7 +25,6 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
     // Open a new yamux stream.
     auto [stream, err] = session_->OpenStream();
     if (err != yamux::Error::OK || !stream) {
-        std::cerr << "[forwarder] failed to open yamux stream" << std::endl;
         sendError(writer, 502);
         return;
     }
@@ -48,7 +46,6 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
     // Serialize and send FetchRequestInfo frame.
     auto reqInfoMsg = proto::EncodeFetchRequest_Info(info);
     if (!writeFrame(stream.get(), reqInfoMsg)) {
-        std::cerr << "[forwarder] failed to write request info" << std::endl;
         stream->Close();
         sendError(writer, 502);
         return;
@@ -65,7 +62,6 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
 
         auto reqDataMsg = proto::EncodeFetchRequest_Data(bodyData);
         if (!writeFrame(stream.get(), reqDataMsg)) {
-            std::cerr << "[forwarder] failed to write request body" << std::endl;
             stream->Close();
             sendError(writer, 502);
             return;
@@ -87,7 +83,6 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
 
         proto::FetchResponse resp;
         if (!proto::DecodeFetchResponse(frame.data(), frame.size(), resp)) {
-            std::cerr << "[forwarder] failed to decode response" << std::endl;
             if (!started) {
                 sendError(writer, 502);
             }
@@ -133,7 +128,9 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
         }
     }
 
-    writer.finish();
+    if (started) {
+        writer.finish();
+    }
     stream->Close();
 }