@aptre/bldr-saucer 0.2.3 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptre/bldr-saucer",
-  "version": "0.2.3",
+  "version": "0.2.6",
   "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.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"
   },
   "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/fetch_proto.cpp

@@ -345,6 +345,33 @@ bool DecodeFetchResponse(const uint8_t* buf, size_t len, FetchResponse& out) {
     return true;
 }
 
+bool DecodeEvalJSRequest(const uint8_t* buf, size_t len, EvalJSRequest& out) {
+    size_t offset = 0;
+    while (offset < len) {
+        uint32_t field;
+        uint8_t wire;
+        if (!decodeTag(buf, len, offset, field, wire)) return false;
+        switch (field) {
+            case 1: { // code
+                if (wire != kLengthDelimited) return false;
+                if (!decodeString(buf, len, offset, out.code)) return false;
+                break;
+            }
+            default:
+                if (!skipField(buf, len, offset, wire)) return false;
+                break;
+        }
+    }
+    return true;
+}
+
+std::vector<uint8_t> EncodeEvalJSResponse(const EvalJSResponse& resp) {
+    std::vector<uint8_t> buf;
+    encodeString(buf, 1, resp.result);
+    encodeString(buf, 2, resp.error);
+    return buf;
+}
+
 bool DecodeSaucerInit(const uint8_t* buf, size_t len, SaucerInit& out) {
     size_t offset = 0;
     while (offset < len) {

package/src/fetch_proto.h

@@ -57,6 +57,23 @@ struct FetchResponse {
     ResponseData data;
 };
 
+// EvalJSRequest corresponds to saucer.EvalJSRequest.
+struct EvalJSRequest {
+    std::string code; // field 1
+};
+
+// EvalJSResponse corresponds to saucer.EvalJSResponse.
+struct EvalJSResponse {
+    std::string result; // field 1
+    std::string error;  // field 2
+};
+
+// DecodeEvalJSRequest decodes an EvalJSRequest protobuf message.
+bool DecodeEvalJSRequest(const uint8_t* buf, size_t len, EvalJSRequest& out);
+
+// EncodeEvalJSResponse encodes an EvalJSResponse protobuf message.
+std::vector<uint8_t> EncodeEvalJSResponse(const EvalJSResponse& resp);
+
 // EncodeFetchRequest_Info serializes a FetchRequest with request_info (field 1).
 std::vector<uint8_t> EncodeFetchRequest_Info(const FetchRequestInfo& info);
 

package/src/main.cpp

@@ -4,15 +4,77 @@
 #include "pipe_connection.h"
 #include "scheme_forwarder.h"
 
+#include <atomic>
+#include <condition_variable>
 #include <cstdlib>
+#include <cstring>
 #include <iostream>
+#include <memory>
+#include <mutex>
 #include <string>
 #include <thread>
+#include <unordered_map>
+#include <vector>
+
+// EvalRegistry tracks pending eval requests and their results.
+// Worker threads register a request ID, execute JS that posts results via
+// the saucer message channel, then wait on a condition variable for the
+// message handler to deliver the result.
+struct EvalRegistry {
+    struct Pending {
+        bool ready = false;
+        std::string result;
+        std::string error;
+    };
+
+    std::mutex mtx;
+    std::condition_variable cv;
+    std::unordered_map<std::string, Pending> pending;
+
+    // Register registers a new eval request and returns the ID.
+    void Register(const std::string& id) {
+        std::lock_guard<std::mutex> lock(mtx);
+        pending[id] = Pending{};
+    }
+
+    // Deliver delivers a result for a pending eval request.
+    // Returns true if the ID was found.
+    bool Deliver(const std::string& id, const std::string& result, const std::string& error) {
+        std::lock_guard<std::mutex> lock(mtx);
+        auto it = pending.find(id);
+        if (it == pending.end()) {
+            return false;
+        }
+        it->second.ready = true;
+        it->second.result = result;
+        it->second.error = error;
+        cv.notify_all();
+        return true;
+    }
+
+    // Wait waits for a result for the given eval ID (up to timeout_ms).
+    // Returns the response, with empty fields on timeout.
+    bldr::proto::EvalJSResponse Wait(const std::string& id, int timeout_ms) {
+        std::unique_lock<std::mutex> lock(mtx);
+        cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this, &id] {
+            auto it = pending.find(id);
+            return it != pending.end() && it->second.ready;
+        });
+        bldr::proto::EvalJSResponse resp;
+        auto it = pending.find(id);
+        if (it != pending.end()) {
+            resp.result = std::move(it->second.result);
+            resp.error = std::move(it->second.error);
+            pending.erase(it);
+        }
+        return resp;
+    }
+};
 
 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 +84,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 +92,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 +103,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 +120,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 +142,162 @@ 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);
+
+    // Eval result registry: worker threads register pending evals, the message
+    // handler delivers results from JavaScript back to the waiting thread.
+    auto eval_registry = std::make_shared<EvalRegistry>();
+
+    // Register a message handler to intercept eval results from JavaScript.
+    // The Go side wraps JS code so it posts the result via postMessage with a
+    // prefix format: __bldr_eval:<eval_id>:r:<result> or __bldr_eval:<eval_id>:e:<error>.
+    // 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 {
+        if (!message.starts_with(eval_prefix)) {
+            return saucer::status::unhandled;
+        }
+
+        // Parse prefix format: __bldr_eval:<eval_id>:<type>:<data>
+        auto rest = message.substr(eval_prefix.size());
+        auto sep1 = rest.find(':');
+        if (sep1 == std::string_view::npos || sep1 + 2 >= rest.size()) {
+            return saucer::status::unhandled;
+        }
+        auto sep2 = rest.find(':', sep1 + 1);
+        if (sep2 == std::string_view::npos) {
+            return saucer::status::unhandled;
+        }
+
+        std::string eval_id(rest.substr(0, sep1));
+        char type = rest[sep1 + 1];
+        std::string data(rest.substr(sep2 + 1));
+
+        if (type == 'r') {
+            eval_registry->Deliver(eval_id, data, "");
+        } else {
+            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.
+    auto* webview_ptr = &(*webview);
+    auto eval_counter = std::make_shared<std::atomic<uint64_t>>(0);
+    std::thread accept_thread([session, webview_ptr, webview_mtx, webview_alive, eval_registry, eval_counter]() {
+        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, eval_registry, eval_counter]() {
+                // 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;
+                }
+
+                // Decode the EvalJSRequest protobuf from Go.
+                bldr::proto::EvalJSRequest req;
+                if (!bldr::proto::DecodeEvalJSRequest(data.data(), data.size(), req)) {
+                    stream->Close();
+                    return;
+                }
+
+                // The code from Go is already wrapped in an async IIFE that posts
+                // the result via postMessage. It contains a placeholder __EVAL_ID__
+                // that we replace with a unique ID for result correlation.
+                std::string code = std::move(req.code);
+                std::string eval_id = "e" + std::to_string(eval_counter->fetch_add(1));
+
+                // Replace the __EVAL_ID__ placeholder with the actual eval ID.
+                const std::string placeholder = "__EVAL_ID__";
+                auto pos = code.find(placeholder);
+                if (pos != std::string::npos) {
+                    code.replace(pos, placeholder.size(), eval_id);
+                }
+
+                // Register the eval request before executing the code.
+                eval_registry->Register(eval_id);
+
+                // 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);
+                    }
+                }
+
+                // Wait for the JavaScript result (30 second timeout).
+                auto resp = eval_registry->Wait(eval_id, 30000);
+                if (resp.result.empty() && resp.error.empty()) {
+                    resp.error = "eval timeout";
+                }
+
+                // Encode the EvalJSResponse protobuf and send it back.
+                auto resp_buf = bldr::proto::EncodeEvalJSResponse(resp);
+                uint8_t resp_len_buf[4];
+                uint32_t resp_len = static_cast<uint32_t>(resp_buf.size());
+                std::memcpy(resp_len_buf, &resp_len, 4);
+                stream->Write(resp_len_buf, 4);
+                stream->Write(resp_buf.data(), resp_buf.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();
 }