bunite-core 0.0.1 → 0.0.4

package/src/native/shared/ffi_exports.h

@@ -1,119 +1,123 @@
-#pragma once
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "callbacks.h"
-
-#if defined(_WIN32)
-#define BUNITE_EXPORT __declspec(dllexport)
-#else
-#define BUNITE_EXPORT __attribute__((visibility("default")))
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-BUNITE_EXPORT bool bunite_init(
-	const char* process_helper_path,
-	const char* cef_dir,
-	bool hide_console,
-	bool popup_blocking,
-	const char* chromium_flags_json
-);
-BUNITE_EXPORT void bunite_run_loop(void);
-BUNITE_EXPORT void bunite_quit(void);
-BUNITE_EXPORT void bunite_free_cstring(const char* value);
-BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler handler);
-BUNITE_EXPORT void bunite_set_window_event_handler(BuniteWindowEventHandler handler);
-
-BUNITE_EXPORT void* bunite_window_create(
-	uint32_t window_id,
-	double x,
-	double y,
-	double width,
-	double height,
-	const char* title,
-	const char* title_bar_style,
-	bool transparent,
-	bool hidden,
-	bool minimized,
-	bool maximized
-);
-BUNITE_EXPORT void bunite_window_show(void* window_ptr);
-BUNITE_EXPORT void bunite_window_close(void* window_ptr);
-BUNITE_EXPORT void bunite_window_set_title(void* window_ptr, const char* title);
-BUNITE_EXPORT void bunite_window_minimize(void* window_ptr);
-BUNITE_EXPORT void bunite_window_unminimize(void* window_ptr);
-BUNITE_EXPORT bool bunite_window_is_minimized(void* window_ptr);
-BUNITE_EXPORT void bunite_window_maximize(void* window_ptr);
-BUNITE_EXPORT void bunite_window_unmaximize(void* window_ptr);
-BUNITE_EXPORT bool bunite_window_is_maximized(void* window_ptr);
-BUNITE_EXPORT void bunite_window_set_frame(
-	void* window_ptr,
-	double x,
-	double y,
-	double width,
-	double height
-);
-
-BUNITE_EXPORT void* bunite_view_create(
-	uint32_t view_id,
-	void* window_ptr,
-	const char* url,
-	const char* html,
-	const char* preload,
-	const char* views_root,
-	const char* navigation_rules_json,
-	double x,
-	double y,
-	double width,
-	double height,
-	bool auto_resize,
-	bool sandbox
-);
-BUNITE_EXPORT void bunite_view_load_url(void* view_ptr, const char* url);
-BUNITE_EXPORT void bunite_view_load_html(void* view_ptr, const char* html);
-BUNITE_EXPORT void bunite_register_view_route(const char* path);
-BUNITE_EXPORT void bunite_unregister_view_route(const char* path);
-BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html);
-BUNITE_EXPORT void bunite_view_set_visible(void* view_ptr, bool visible);
-BUNITE_EXPORT void bunite_view_set_bounds(
-	void* view_ptr,
-	double x,
-	double y,
-	double width,
-	double height
-);
-BUNITE_EXPORT void bunite_view_set_anchor(void* view_ptr, int mode, double inset);
-BUNITE_EXPORT void bunite_view_go_back(void* view_ptr);
-BUNITE_EXPORT void bunite_view_reload(void* view_ptr);
-BUNITE_EXPORT void bunite_view_remove(void* view_ptr);
-BUNITE_EXPORT void bunite_view_open_devtools(void* view_ptr);
-BUNITE_EXPORT void bunite_view_close_devtools(void* view_ptr);
-BUNITE_EXPORT void bunite_view_toggle_devtools(void* view_ptr);
-BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state);
-BUNITE_EXPORT int32_t bunite_show_message_box(
-	const char* type,
-	const char* title,
-	const char* message,
-	const char* detail,
-	const char* buttons,
-	int32_t default_id,
-	int32_t cancel_id
-);
-BUNITE_EXPORT uint32_t bunite_show_browser_message_box(
-	const char* type,
-	const char* title,
-	const char* message,
-	const char* detail,
-	const char* buttons,
-	int32_t default_id,
-	int32_t cancel_id
-);
-BUNITE_EXPORT void bunite_cancel_browser_message_box(uint32_t request_id);
-
-#ifdef __cplusplus
-}
-#endif
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "callbacks.h"
+
+#if defined(_WIN32)
+#define BUNITE_EXPORT __declspec(dllexport)
+#else
+#define BUNITE_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+BUNITE_EXPORT int32_t bunite_abi_version(void);
+BUNITE_EXPORT void bunite_set_log_level(int32_t level);
+BUNITE_EXPORT bool bunite_init(
+	const char* process_helper_path,
+	const char* cef_dir,
+	bool hide_console,
+	bool popup_blocking,
+	const char* chromium_flags_json
+);
+BUNITE_EXPORT void bunite_run_loop(void);
+BUNITE_EXPORT void bunite_quit(void);
+BUNITE_EXPORT void bunite_free_cstring(const char* value);
+BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler handler);
+BUNITE_EXPORT void bunite_set_window_event_handler(BuniteWindowEventHandler handler);
+
+BUNITE_EXPORT bool bunite_window_create(
+	uint32_t window_id,
+	double x,
+	double y,
+	double width,
+	double height,
+	const char* title,
+	const char* title_bar_style,
+	bool transparent,
+	bool hidden,
+	bool minimized,
+	bool maximized
+);
+BUNITE_EXPORT void bunite_window_destroy(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_reset_close_pending(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_show(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_close(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_set_title(uint32_t window_id, const char* title);
+BUNITE_EXPORT void bunite_window_minimize(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_unminimize(uint32_t window_id);
+BUNITE_EXPORT bool bunite_window_is_minimized(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_maximize(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_unmaximize(uint32_t window_id);
+BUNITE_EXPORT bool bunite_window_is_maximized(uint32_t window_id);
+BUNITE_EXPORT void bunite_window_set_frame(
+	uint32_t window_id,
+	double x,
+	double y,
+	double width,
+	double height
+);
+
+BUNITE_EXPORT bool bunite_view_create(
+	uint32_t view_id,
+	uint32_t window_id,
+	const char* url,
+	const char* html,
+	const char* preload,
+	const char* appres_root,
+	const char* navigation_rules_json,
+	double x,
+	double y,
+	double width,
+	double height,
+	bool auto_resize,
+	bool sandbox,
+	const char* preload_origins_json
+);
+BUNITE_EXPORT void bunite_view_execute_javascript(uint32_t view_id, const char* script);
+BUNITE_EXPORT void bunite_view_load_url(uint32_t view_id, const char* url);
+BUNITE_EXPORT void bunite_view_load_html(uint32_t view_id, const char* html);
+BUNITE_EXPORT void bunite_register_appres_route(const char* path);
+BUNITE_EXPORT void bunite_unregister_appres_route(const char* path);
+BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html);
+BUNITE_EXPORT void bunite_view_set_visible(uint32_t view_id, bool visible);
+BUNITE_EXPORT void bunite_view_bring_to_front(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_set_bounds(
+	uint32_t view_id,
+	double x,
+	double y,
+	double width,
+	double height
+);
+BUNITE_EXPORT void bunite_view_set_bounds_async(
+	uint32_t view_id,
+	double x,
+	double y,
+	double width,
+	double height
+);
+BUNITE_EXPORT void bunite_view_set_anchor(uint32_t view_id, int mode, double inset);
+BUNITE_EXPORT void bunite_view_go_back(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_reload(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_remove(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_close_devtools(uint32_t view_id);
+BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id);
+BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state);
+BUNITE_EXPORT int32_t bunite_show_message_box(
+	uint32_t window_id,
+	const char* type,
+	const char* title,
+	const char* message,
+	const char* detail,
+	const char* buttons,
+	int32_t default_id,
+	int32_t cancel_id
+);
+#ifdef __cplusplus
+}
+#endif

package/src/native/shared/log.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstdio>
+#include <atomic>
+
+enum class BuniteLogLevel : int { Debug = 0, Info = 1, Warn = 2, Error = 3, Silent = 4 };
+
+inline std::atomic<BuniteLogLevel> g_bunite_log_level{BuniteLogLevel::Warn};
+
+inline void buniteSetLogLevel(BuniteLogLevel level) {
+  g_bunite_log_level.store(level, std::memory_order_relaxed);
+}
+
+inline bool buniteShouldLog(BuniteLogLevel level) {
+  return static_cast<int>(level) >= static_cast<int>(g_bunite_log_level.load(std::memory_order_relaxed));
+}
+
+#define BUNITE_LOG(level, fmt, ...) \
+  do { if (buniteShouldLog(level)) std::fprintf(stderr, "[bunite/native] " fmt "\n", ##__VA_ARGS__); } while (0)
+
+#define BUNITE_DEBUG(fmt, ...) BUNITE_LOG(BuniteLogLevel::Debug, fmt, ##__VA_ARGS__)
+#define BUNITE_INFO(fmt, ...)  BUNITE_LOG(BuniteLogLevel::Info, fmt, ##__VA_ARGS__)
+#define BUNITE_WARN(fmt, ...)  BUNITE_LOG(BuniteLogLevel::Warn, fmt, ##__VA_ARGS__)
+#define BUNITE_ERROR(fmt, ...) BUNITE_LOG(BuniteLogLevel::Error, fmt, ##__VA_ARGS__)

package/src/native/shared/webview_storage.h

@@ -39,13 +39,13 @@ private:
   std::map<uint32_t, std::string> content_;
 };
 
-// Tracks which views:// paths have registered dynamic handlers on the Bun side.
+// Tracks which appres:// paths have registered dynamic handlers on the Bun side.
 // The actual handler function lives in JS; this only stores the set of registered paths
 // and completed route responses.
-class ViewsRouteStorage {
+class AppResRouteStorage {
 public:
-  static ViewsRouteStorage& instance() {
-    static ViewsRouteStorage storage;
+  static AppResRouteStorage& instance() {
+    static AppResRouteStorage storage;
     return storage;
   }
 
@@ -79,7 +79,7 @@ public:
   }
 
 private:
-  ViewsRouteStorage() = default;
+  AppResRouteStorage() = default;
 
   mutable std::mutex mutex_;
   std::set<std::string> registered_;

package/src/native/win/native_host_appres.cpp

@@ -0,0 +1,258 @@
+#include "native_host_internal.h"
+
+namespace {
+
+class BuniteSchemeHandler : public CefResourceHandler {
+public:
+  explicit BuniteSchemeHandler(uint32_t view_id)
+    : view_id_(view_id) {}
+
+  bool Open(CefRefPtr<CefRequest> request, bool& handle_request, CefRefPtr<CefCallback> callback) override {
+    CEF_REQUIRE_IO_THREAD();
+    handle_request = true;
+
+    const std::string url = request ? request->GetURL().ToString() : "";
+
+    CefURLParts url_parts;
+    if (CefParseURL(url, url_parts)) {
+      const std::string host = CefString(&url_parts.host).ToString();
+      if (host != "app.internal") {
+        status_code_ = 403;
+        status_text_ = "Forbidden";
+        mime_type_ = "text/plain";
+        data_ = "Invalid appres host: " + host;
+        return true;
+      }
+    }
+
+    const std::string normalized_path = bunite_win::normalizeAppResPath(url);
+
+    // Dynamic route: handler lives on the Bun side, request is async
+    if (bunite::AppResRouteStorage::instance().hasRoute(normalized_path)) {
+      handle_request = false; // async - we'll call callback->Continue() later
+      uint32_t request_id;
+      {
+        std::lock_guard<std::mutex> lock(g_runtime.route_mutex);
+        request_id = g_runtime.next_route_request_id++;
+        g_runtime.pending_routes[request_id] = { normalized_path, callback, request };
+      }
+      pending_route_request_id_ = request_id;
+      bunite_win::emitWebviewEvent(
+        view_id_,
+        "route-request",
+        "{\"requestId\":" + std::to_string(request_id) +
+          ",\"path\":\"" + bunite_win::escapeJsonString(normalized_path) + "\"}"
+      );
+      return true;
+    }
+
+    std::string mime_type;
+    const auto content = bunite_win::loadAppResResource(view_id_, url, mime_type);
+    if (!content) {
+      const std::string appres_root = bunite_win::getAppResRootForView(view_id_);
+      BUNITE_WARN("appres:// resource not found (view=%u, url=%s, normalized=%s, root=%s)",
+        view_id_, url.c_str(), normalized_path.c_str(), appres_root.c_str());
+      status_code_ = 404;
+      status_text_ = "Not Found";
+      mime_type_ = "text/plain";
+      data_ =
+        "bunite could not resolve the requested appres:// resource.\n"
+        "url: " + url + "\n" +
+        "normalized: " + normalized_path;
+      return true;
+    }
+
+    status_code_ = 200;
+    status_text_ = "OK";
+    mime_type_ = mime_type;
+    data_ = *content;
+    return true;
+  }
+
+  void GetResponseHeaders(CefRefPtr<CefResponse> response, int64_t& response_length, CefString&) override {
+    if (pending_route_request_id_ != 0) {
+      auto content = bunite::AppResRouteStorage::instance().takeResponse(pending_route_request_id_);
+      pending_route_request_id_ = 0;
+      if (content) {
+        status_code_ = 200;
+        status_text_ = "OK";
+        mime_type_ = "text/html";
+        data_ = std::move(*content);
+      } else {
+        status_code_ = 500;
+        status_text_ = "Handler Error";
+        mime_type_ = "text/plain";
+        data_ = "Route handler did not produce a response.";
+      }
+    }
+    response->SetStatus(status_code_);
+    response->SetStatusText(status_text_);
+    response->SetMimeType(mime_type_);
+    response_length = static_cast<int64_t>(data_.size());
+  }
+
+  bool Read(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr<CefResourceReadCallback>) override {
+    CEF_REQUIRE_IO_THREAD();
+    bytes_read = 0;
+    if (offset_ >= data_.size()) {
+      return false;
+    }
+
+    const size_t remaining = data_.size() - offset_;
+    const size_t count = std::min<size_t>(remaining, static_cast<size_t>(bytes_to_read));
+    std::memcpy(data_out, data_.data() + offset_, count);
+    offset_ += count;
+    bytes_read = static_cast<int>(count);
+    return true;
+  }
+
+  void Cancel() override {
+    CEF_REQUIRE_IO_THREAD();
+  }
+
+private:
+  uint32_t view_id_;
+  uint32_t pending_route_request_id_ = 0;
+  std::string data_;
+  std::string mime_type_ = "text/plain";
+  std::string status_text_ = "OK";
+  size_t offset_ = 0;
+  int status_code_ = 200;
+
+  IMPLEMENT_REFCOUNTING(BuniteSchemeHandler);
+};
+
+class BuniteSchemeHandlerFactory : public CefSchemeHandlerFactory {
+public:
+  CefRefPtr<CefResourceHandler> Create(
+    CefRefPtr<CefBrowser> browser,
+    CefRefPtr<CefFrame>,
+    const CefString&,
+    CefRefPtr<CefRequest>
+  ) override {
+    uint32_t view_id = 0;
+    if (browser) {
+      std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+      const auto it = g_runtime.browser_to_view_id.find(browser->GetIdentifier());
+      if (it != g_runtime.browser_to_view_id.end()) {
+        view_id = it->second;
+      }
+    }
+    return new BuniteSchemeHandler(view_id);
+  }
+
+private:
+  IMPLEMENT_REFCOUNTING(BuniteSchemeHandlerFactory);
+};
+
+} // namespace
+
+namespace bunite_win {
+
+std::string normalizeAppResPath(const std::string& url) {
+  CefURLParts parts;
+  if (CefParseURL(url, parts)) {
+    std::string path = CefString(&parts.path).ToString();
+    while (!path.empty() && (path.front() == '/' || path.front() == '\\')) {
+      path.erase(path.begin());
+    }
+    while (!path.empty() && (path.back() == '/' || path.back() == '\\')) {
+      path.pop_back();
+    }
+    return path.empty() ? "index.html" : path;
+  }
+
+  std::string path = url;
+  if (path.rfind("appres://", 0) == 0) {
+    path = path.substr(9); // "appres://" is 9 chars
+    const auto slash_pos = path.find('/');
+    path = (slash_pos != std::string::npos) ? path.substr(slash_pos + 1) : "";
+  }
+
+  const auto query_pos = path.find_first_of("?#");
+  if (query_pos != std::string::npos) {
+    path = path.substr(0, query_pos);
+  }
+
+  while (!path.empty() && (path.back() == '/' || path.back() == '\\')) {
+    path.pop_back();
+  }
+
+  return path.empty() ? "index.html" : path;
+}
+
+std::string getMimeType(const std::filesystem::path& file_path) {
+  const auto extension = file_path.extension().string();
+  if (extension == ".html" || extension == ".htm") return "text/html";
+  if (extension == ".js" || extension == ".mjs") return "text/javascript";
+  if (extension == ".css") return "text/css";
+  if (extension == ".json") return "application/json";
+  if (extension == ".svg") return "image/svg+xml";
+  if (extension == ".png") return "image/png";
+  if (extension == ".jpg" || extension == ".jpeg") return "image/jpeg";
+  if (extension == ".woff2") return "font/woff2";
+  if (extension == ".woff") return "font/woff";
+  if (extension == ".ttf") return "font/ttf";
+  return "application/octet-stream";
+}
+
+std::string getAppResRootForView(uint32_t view_id) {
+  std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+  const auto it = g_runtime.views_by_id.find(view_id);
+  if (it == g_runtime.views_by_id.end() || !it->second) {
+    return {};
+  }
+  return it->second->appres_root;
+}
+
+std::optional<std::string> loadAppResResource(uint32_t view_id, const std::string& url, std::string& mime_type) {
+  const std::string appres_root = getAppResRootForView(view_id);
+
+  const std::string path = normalizeAppResPath(url);
+  if (path == "internal/index.html") {
+    mime_type = "text/html";
+    return bunite::WebviewContentStorage::instance().get(view_id);
+  }
+
+  if (appres_root.empty()) {
+    return std::nullopt;
+  }
+
+  if (!std::filesystem::exists(appres_root)) {
+    return std::nullopt;
+  }
+
+  const std::filesystem::path root = std::filesystem::weakly_canonical(std::filesystem::path(appres_root));
+  std::filesystem::path candidate = std::filesystem::weakly_canonical(root / std::filesystem::path(path));
+  if (std::filesystem::exists(candidate) && std::filesystem::is_directory(candidate)) {
+    candidate = std::filesystem::weakly_canonical(candidate / "index.html");
+  } else if (!std::filesystem::exists(candidate) && !candidate.has_extension()) {
+    candidate = std::filesystem::weakly_canonical(std::filesystem::path(candidate.native() + L".html"));
+  }
+  const auto root_string = root.native();
+  const auto candidate_string = candidate.native();
+  const bool in_root = candidate_string == root_string ||
+    (candidate_string.size() > root_string.size() &&
+      candidate_string.rfind(root_string, 0) == 0 &&
+      (candidate_string[root_string.size()] == L'\\' || candidate_string[root_string.size()] == L'/'));
+
+  if (!in_root || !std::filesystem::exists(candidate) || std::filesystem::is_directory(candidate)) {
+    return std::nullopt;
+  }
+
+  std::ifstream stream(candidate, std::ios::binary);
+  if (!stream) {
+    return std::nullopt;
+  }
+
+  std::ostringstream contents;
+  contents << stream.rdbuf();
+  mime_type = getMimeType(candidate);
+  return contents.str();
+}
+
+void registerAppResSchemeHandlers() {
+  CefRegisterSchemeHandlerFactory("appres", "", new BuniteSchemeHandlerFactory());
+}
+
+} // namespace bunite_win