@aptre/bldr-saucer 0.2.2 → 0.2.5

package/CMakeLists.txt

@@ -34,7 +34,6 @@ add_executable(bldr-saucer
 )
 
 target_link_libraries(bldr-saucer PRIVATE saucer::saucer yamux)
-target_compile_features(bldr-saucer PRIVATE cxx_std_23)
 
 # Platform-specific socket libraries.
 if(WIN32)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptre/bldr-saucer",
-  "version": "0.2.2",
+  "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.2",
-    "@aptre/bldr-saucer-darwin-x64": "0.2.2",
-    "@aptre/bldr-saucer-linux-x64": "0.2.2",
-    "@aptre/bldr-saucer-linux-arm64": "0.2.2",
-    "@aptre/bldr-saucer-win32-x64": "0.2.2"
+    "@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;
@@ -21,8 +26,8 @@ coco::stray start(saucer::application* app) {
     const char* init_b64 = std::getenv("BLDR_SAUCER_INIT");
     if (init_b64) {
         auto data = bldr::proto::Base64Decode(init_b64);
-        if (!data.empty()) {
-            bldr::proto::DecodeSaucerInit(data.data(), data.size(), saucer_init);
+        if (!data.empty() && !bldr::proto::DecodeSaucerInit(data.data(), data.size(), saucer_init)) {
+            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
@@ -40,7 +41,7 @@ bool PipeClient::connect(const std::string& pipe_path) {
         return false;
     }
 
-    // Set pipe mode to message mode
+    // Set pipe to byte read mode.
     DWORD mode = PIPE_READMODE_BYTE;
     if (!SetNamedPipeHandleState(handle_, &mode, nullptr, nullptr)) {
         std::cerr << "Failed to set pipe mode: " << GetLastError() << std::endl;
@@ -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,19 +200,27 @@ 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;
     }
 
 #ifdef _WIN32
-    DWORD bytes_written = 0;
-    if (!WriteFile(handle_, data, (DWORD)length, &bytes_written, nullptr)) {
-        connected_ = false;
-        return false;
+    size_t total_written = 0;
+    while (total_written < length) {
+        DWORD bytes_written = 0;
+        if (!WriteFile(handle_, data + total_written, (DWORD)(length - total_written), &bytes_written, nullptr)) {
+            connected_ = false;
+            return false;
+        }
+        if (bytes_written == 0) {
+            connected_ = false;
+            return false;
+        }
+        total_written += bytes_written;
     }
-    return bytes_written == length;
+    return true;
 #else
     size_t total_written = 0;
     while (total_written < length) {

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

@@ -1,18 +1,31 @@
 #include "scheme_forwarder.h"
 
+#include <algorithm>
+#include <cctype>
 #include <cstring>
-#include <iostream>
 
 namespace bldr {
 
+// toLower returns a lowercase copy of the string.
+static std::string toLower(const std::string& s) {
+    std::string out = s;
+    std::transform(out.begin(), out.end(), out.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
+    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();
+}
+
 void SchemeForwarder::forward(const saucer::scheme::request& req,
                                saucer::scheme::stream_writer& writer) {
     // 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;
-        writer.start({.mime = "text/plain", .status = 502});
-        writer.finish();
+        sendError(writer, 502);
         return;
     }
 
@@ -33,10 +46,8 @@ 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();
-        writer.start({.mime = "text/plain", .status = 502});
-        writer.finish();
+        sendError(writer, 502);
         return;
     }
 
@@ -51,10 +62,8 @@ 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();
-            writer.start({.mime = "text/plain", .status = 502});
-            writer.finish();
+            sendError(writer, 502);
             return;
         }
     }
@@ -67,16 +76,15 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
         std::vector<uint8_t> frame;
         if (!readFrame(stream.get(), frame)) {
             if (!started) {
-                writer.start({.mime = "text/plain", .status = 502});
+                sendError(writer, 502);
             }
             break;
         }
 
         proto::FetchResponse resp;
         if (!proto::DecodeFetchResponse(frame.data(), frame.size(), resp)) {
-            std::cerr << "[forwarder] failed to decode response" << std::endl;
             if (!started) {
-                writer.start({.mime = "text/plain", .status = 502});
+                sendError(writer, 502);
             }
             break;
         }
@@ -85,20 +93,13 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
         if (resp.has_info && !started) {
             started = true;
 
-            // Determine MIME type from Content-Type header.
+            // Extract Content-Type header (case-insensitive).
             std::string mime = "application/octet-stream";
-            auto it = resp.info.headers.find("Content-Type");
-            if (it == resp.info.headers.end()) {
-                it = resp.info.headers.find("content-type");
-            }
-            if (it != resp.info.headers.end()) {
-                mime = it->second;
-            }
-
-            // Build response headers for saucer (excluding Content-Type which goes in mime).
             std::map<std::string, std::string> hdrs;
             for (const auto& [key, val] : resp.info.headers) {
-                if (key != "Content-Type" && key != "content-type") {
+                if (toLower(key) == "content-type") {
+                    mime = val;
+                } else {
                     hdrs[key] = val;
                 }
             }
@@ -127,7 +128,9 @@ void SchemeForwarder::forward(const saucer::scheme::request& req,
         }
     }
 
-    writer.finish();
+    if (started) {
+        writer.finish();
+    }
     stream->Close();
 }
 
@@ -135,7 +138,7 @@ bool SchemeForwarder::writeFrame(yamux::Stream* stream, const std::vector<uint8_
     // Write LittleEndian uint32 length prefix.
     uint8_t lenBuf[4];
     uint32_t msgLen = static_cast<uint32_t>(data.size());
-    std::memcpy(lenBuf, &msgLen, 4); // LE on LE platforms
+    std::memcpy(lenBuf, &msgLen, 4); // LE on LE platforms (x86_64, ARM64)
 
     auto err = stream->Write(lenBuf, 4);
     if (err != yamux::Error::OK) return false;
@@ -155,7 +158,7 @@ bool SchemeForwarder::readFrame(yamux::Stream* stream, std::vector<uint8_t>& out
     }
 
     uint32_t msgLen;
-    std::memcpy(&msgLen, lenBuf, 4); // LE on LE platforms
+    std::memcpy(&msgLen, lenBuf, 4); // LE on LE platforms (x86_64, ARM64)
 
     if (msgLen > kMaxFrameSize) return false;