bunite-core 0.5.0 → 0.8.0

package/src/native/mac/bunite_mac_internal.h

@@ -0,0 +1,151 @@
+// macOS adapter — shared internal declarations.
+//
+// ARC: Obj-C objects in C++ aggregates need explicit __strong/__weak (else UB).
+// Threading: NSWindow / WKWebView APIs are main-thread-only — cross-thread via runOnUiThreadSync.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+#import <WebKit/WebKit.h>
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "callbacks.h"
+#include "ffi_exports.h"
+#include "log.h"
+#include "permissions.h"
+
+@interface BunitePendingPermission : NSObject
+@property (nonatomic, assign) uint32_t viewId;
+@property (nonatomic, copy) void (^handler)(WKPermissionDecision);
+@end
+
+@interface BunitePendingRoute : NSObject
+@property (nonatomic, assign) uint32_t viewId;
+@property (nonatomic, strong) id<WKURLSchemeTask> task;
+@end
+
+// Stable host for passthrough + mask (WKWebView's internal subviews are fragile).
+// Layer-backed (CAShapeLayer mask), isFlipped (coords match BuniteFlippedView).
+// `maskHoles` gates hitTest alongside the visual mask — clicks pass through (matches win SetWindowRgn).
+@interface BunitePassthroughContainer : NSView
+@property (nonatomic, assign) BOOL passthrough;
+@property (nonatomic, copy) NSArray<NSValue*>* maskHoles;  // NSValue.rectValue
+@end
+
+namespace bunite_mac {
+
+// --- Per-object state ---
+
+struct WindowState {
+  __strong NSWindow* window = nil;
+  __strong NSObject<NSWindowDelegate>* delegate = nil;
+  std::atomic<bool> close_pending{false};
+};
+
+struct ViewState {
+  __strong BunitePassthroughContainer* container = nil;  // window.contentView 자식
+  __strong WKWebView* webview = nil;                     // container 자식 (autoresize 채움)
+  __strong NSObject<WKNavigationDelegate>* nav_delegate = nil;
+  __strong NSObject<WKUIDelegate>* ui_delegate = nil;
+  uint32_t window_id = 0;
+  std::string appres_root;
+  std::string preload_script;
+  // HTML stashed by load_html; appres handler serves at internal/index.html.
+  std::string stored_html;
+  std::vector<std::string> navigation_rules;
+};
+
+// ---------------------------------------------------------------------------
+// Runtime singleton.
+// ---------------------------------------------------------------------------
+
+struct RuntimeState {
+  std::mutex object_mutex;
+  std::unordered_map<uint32_t, WindowState> windows;
+  std::unordered_map<uint32_t, ViewState> views;
+
+  bool initialized = false;
+  bool popup_blocking = false;
+  std::atomic<bool> shutting_down{false};
+
+  // Pending permission decisions (request_id → entry). Main-thread only, no mutex.
+  __strong NSMutableDictionary<NSNumber*, BunitePendingPermission*>* pending_permissions = nil;
+  uint32_t next_permission_request_id = 1;
+
+  // In-flight dynamic-route tasks (request_id → entry). view_id lets removeView clean up without WebKit stop. Main-thread only.
+  __strong NSMutableDictionary<NSNumber*, BunitePendingRoute*>* pending_route_tasks = nil;
+  uint32_t next_route_request_id = 1;
+
+  BuniteWebviewEventHandler webview_event_handler = nullptr;
+  BuniteWindowEventHandler window_event_handler = nullptr;
+};
+
+extern RuntimeState g_runtime;
+
+// --- Thread helpers (main-thread fast path; cross-thread = dispatch_sync) ---
+
+bool isOnMainThread();
+
+template <typename Block>
+auto runOnUiThreadSync(Block block) -> decltype(block()) {
+  using R = decltype(block());
+  if (isOnMainThread()) return block();
+  if constexpr (std::is_void_v<R>) {
+    dispatch_sync(dispatch_get_main_queue(), ^{ block(); });
+  } else {
+    __block R result{};
+    dispatch_sync(dispatch_get_main_queue(), ^{ result = block(); });
+    return result;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Utilities (defined in bunite_mac_utils.mm).
+// ---------------------------------------------------------------------------
+
+NSString* utf8ToNSString(const char* value);
+
+std::string escapeJsonString(const std::string& value);
+
+// Cocoa screen is bottom-left, Win semantics (and FFI) are top-left.
+NSRect topLeftToBottomLeft(double x, double y, double width, double height);
+void bottomLeftToTopLeft(NSRect frame, double* out_x, double* out_y, double* out_w, double* out_h);
+
+// Payload must be valid UTF-8 JSON.
+void emitWindowEvent(uint32_t window_id, const char* event_name, const std::string& payload = {});
+void emitWebviewEvent(uint32_t view_id, const char* event_name, const std::string& payload = {});
+
+// Defined in bunite_mac_window.mm.
+WindowState* findWindow(uint32_t window_id);  // returns nullptr if missing
+bool createWindow(uint32_t window_id, double x, double y, double width, double height,
+                  NSString* title, NSString* title_bar_style,
+                  bool transparent, bool hidden, bool minimized, bool maximized);
+void destroyWindow(uint32_t window_id);
+
+// Defined in bunite_mac_view.mm.
+ViewState* findView(uint32_t view_id);
+uint32_t viewIdForWebView(WKWebView* wv);  // returns 0 if not tracked
+bool createView(uint32_t view_id, uint32_t window_id,
+                NSString* url, NSString* html, NSString* preload, NSString* appres_root,
+                NSString* navigation_rules_json, NSString* preload_origins_json,
+                double x, double y, double width, double height, bool auto_resize);
+void removeView(uint32_t view_id);
+
+// Glob patterns, last-match-wins, default-allow.
+bool globMatchCaseInsensitive(const std::string& pattern, const std::string& value);
+std::vector<std::string> parseNavigationRulesJson(NSString* json);
+bool shouldAlwaysAllowNavigationUrl(const std::string& url);
+bool shouldAllowNavigation(const ViewState* view, const std::string& url);
+
+// Defined in bunite_mac_appres.mm.
+id<WKURLSchemeHandler> sharedAppresSchemeHandler();
+
+} // namespace bunite_mac

package/src/native/mac/bunite_mac_runtime.mm

@@ -0,0 +1,15 @@
+// Process-wide singletons + thread helpers + NSApp lifecycle for the macOS adapter.
+
+#import "bunite_mac_internal.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+namespace bunite_mac {
+
+RuntimeState g_runtime;
+
+bool isOnMainThread() {
+  return [NSThread isMainThread] == YES;
+}
+
+} // namespace bunite_mac

package/src/native/mac/bunite_mac_utils.mm

@@ -0,0 +1,121 @@
+// String conversion + event emit helpers + navigation rule matching.
+
+#import "bunite_mac_internal.h"
+
+#include <cctype>
+#include <cstdio>
+#include <cstring>  // strdup
+
+namespace bunite_mac {
+
+NSString* utf8ToNSString(const char* value) {
+  if (!value) return @"";
+  return [NSString stringWithUTF8String:value] ?: @"";
+}
+
+std::string escapeJsonString(const std::string& value) {
+  std::string out;
+  out.reserve(value.size() + 8);
+  for (unsigned char c : value) {
+    switch (c) {
+      case '"':  out += "\\\""; break;
+      case '\\': out += "\\\\"; break;
+      case '\b': out += "\\b"; break;
+      case '\f': out += "\\f"; break;
+      case '\n': out += "\\n"; break;
+      case '\r': out += "\\r"; break;
+      case '\t': out += "\\t"; break;
+      default:
+        if (c < 0x20) {
+          char buf[8];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out += buf;
+        } else {
+          out += static_cast<char>(c);
+        }
+    }
+  }
+  return out;
+}
+
+NSRect topLeftToBottomLeft(double x, double y, double width, double height) {
+  CGFloat screenH = [NSScreen mainScreen].frame.size.height;
+  return NSMakeRect(x, screenH - y - height, width, height);
+}
+
+void bottomLeftToTopLeft(NSRect frame, double* out_x, double* out_y, double* out_w, double* out_h) {
+  CGFloat screenH = [NSScreen mainScreen].frame.size.height;
+  *out_x = frame.origin.x;
+  *out_y = screenH - frame.origin.y - frame.size.height;
+  *out_w = frame.size.width;
+  *out_h = frame.size.height;
+}
+
+void emitWindowEvent(uint32_t window_id, const char* event_name, const std::string& payload) {
+  // Bun calls bunite_free_cstring — strdup so we don't return .rodata or temporary pointers.
+  if (BuniteWindowEventHandler h = g_runtime.window_event_handler) {
+    h(window_id, strdup(event_name ? event_name : ""), strdup(payload.c_str()));
+  }
+}
+
+void emitWebviewEvent(uint32_t view_id, const char* event_name, const std::string& payload) {
+  if (BuniteWebviewEventHandler h = g_runtime.webview_event_handler) {
+    h(view_id, strdup(event_name ? event_name : ""), strdup(payload.c_str()));
+  }
+}
+
+bool globMatchCaseInsensitive(const std::string& pattern, const std::string& value) {
+  size_t pi = 0, vi = 0;
+  size_t star_p = std::string::npos, star_v = 0;
+  while (vi < value.size()) {
+    if (pi < pattern.size() &&
+        std::tolower(static_cast<unsigned char>(pattern[pi])) ==
+        std::tolower(static_cast<unsigned char>(value[vi]))) {
+      ++pi; ++vi;
+    } else if (pi < pattern.size() && pattern[pi] == '*') {
+      star_p = pi++; star_v = vi;
+    } else if (star_p != std::string::npos) {
+      pi = star_p + 1; vi = ++star_v;
+    } else {
+      return false;
+    }
+  }
+  while (pi < pattern.size() && pattern[pi] == '*') ++pi;
+  return pi == pattern.size();
+}
+
+std::vector<std::string> parseNavigationRulesJson(NSString* json) {
+  std::vector<std::string> rules;
+  if (json.length == 0) return rules;
+  NSData* data = [json dataUsingEncoding:NSUTF8StringEncoding];
+  if (!data) return rules;
+  id parsed = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+  if (![parsed isKindOfClass:[NSArray class]]) return rules;
+  for (id entry in (NSArray*)parsed) {
+    if (![entry isKindOfClass:[NSString class]]) continue;
+    const char* s = [(NSString*)entry UTF8String];
+    if (s && *s) rules.emplace_back(s);
+  }
+  return rules;
+}
+
+bool shouldAlwaysAllowNavigationUrl(const std::string& url) {
+  return url == "about:blank" ||
+         url.rfind("appres://app.internal/internal/", 0) == 0;
+}
+
+bool shouldAllowNavigation(const ViewState* view, const std::string& url) {
+  if (!view || shouldAlwaysAllowNavigationUrl(url) || view->navigation_rules.empty()) {
+    return true;
+  }
+  bool allowed = true;  // default-allow, last-match-wins
+  for (const std::string& raw : view->navigation_rules) {
+    const bool block = !raw.empty() && raw.front() == '^';
+    const std::string pattern = block ? raw.substr(1) : raw;
+    if (pattern.empty()) continue;
+    if (globMatchCaseInsensitive(pattern, url)) allowed = !block;
+  }
+  return allowed;
+}
+
+} // namespace bunite_mac

package/src/native/mac/bunite_mac_view.mm

@@ -0,0 +1,279 @@
+// WKWebView lifecycle + navigation/UI delegates.
+
+#import "bunite_mac_internal.h"
+
+#include "webview_storage.h"
+
+@implementation BunitePendingPermission
+@end
+
+@implementation BunitePendingRoute
+@end
+
+@implementation BunitePassthroughContainer
+- (BOOL)isFlipped { return YES; }
+- (NSView*)hitTest:(NSPoint)point {
+  if (self.passthrough) return nil;
+  if (self.maskHoles.count > 0) {
+    NSPoint local = [self convertPoint:point fromView:self.superview];
+    for (NSValue* v in self.maskHoles) {
+      if (NSPointInRect(local, v.rectValue)) return nil;
+    }
+  }
+  return [super hitTest:point];
+}
+@end
+
+using bunite_mac::g_runtime;
+using bunite_mac::utf8ToNSString;
+
+@interface BuniteNavigationDelegate : NSObject <WKNavigationDelegate>
+@end
+
+@implementation BuniteNavigationDelegate
+
+- (void)webView:(WKWebView*)wv
+decidePolicyForNavigationAction:(WKNavigationAction*)action
+       decisionHandler:(void(^)(WKNavigationActionPolicy))decisionHandler
+{
+  // nil targetFrame = popup (window.open, target=_blank, ctrl-click); apply main-frame rules.
+  if (action.targetFrame && !action.targetFrame.mainFrame) {
+    decisionHandler(WKNavigationActionPolicyAllow);
+    return;
+  }
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  const std::string url_str = (action.request.URL.absoluteString ?: @"").UTF8String;
+  // Evaluate before will-navigate — a synchronous handler could destroy the view.
+  const bool allow = bunite_mac::shouldAllowNavigation(bunite_mac::findView(view_id), url_str);
+  bunite_mac::emitWebviewEvent(view_id, "will-navigate", url_str);
+  decisionHandler(allow ? WKNavigationActionPolicyAllow : WKNavigationActionPolicyCancel);
+}
+
+- (void)webView:(WKWebView*)wv didFinishNavigation:(WKNavigation*)nav {
+  (void)nav;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* url = wv.URL.absoluteString ?: @"";
+  bunite_mac::emitWebviewEvent(view_id, "did-navigate", url.UTF8String);
+  bunite_mac::emitWebviewEvent(view_id, "dom-ready", url.UTF8String);
+}
+
+@end
+
+@interface BuniteUIDelegate : NSObject <WKUIDelegate>
+@end
+
+@implementation BuniteUIDelegate
+
+- (WKWebView*)webView:(WKWebView*)wv
+createWebViewWithConfiguration:(WKWebViewConfiguration*)config
+              forNavigationAction:(WKNavigationAction*)action
+                   windowFeatures:(WKWindowFeatures*)features
+{
+  (void)config; (void)features;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* url = action.request.URL.absoluteString ?: @"";
+  // Match win OnBeforePopup/OnOpenURLFromTab: emit, cancel; JS decides via load_url.
+  std::string payload = "{\"url\":\"" +
+    bunite_mac::escapeJsonString(url.UTF8String ?: "") + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "new-window-open", payload);
+  return nil;
+}
+
+- (void)webView:(WKWebView*)wv
+requestMediaCapturePermissionForOrigin:(WKSecurityOrigin*)origin
+              initiatedByFrame:(WKFrameInfo*)frame
+                          type:(WKMediaCaptureType)type
+              decisionHandler:(void(^)(WKPermissionDecision))decisionHandler
+              API_AVAILABLE(macos(12.0))
+{
+  (void)frame;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  uint32_t kind = 0;
+  switch (type) {
+    case WKMediaCaptureTypeCamera:
+      kind = BUNITE_PERMISSION_CAMERA; break;
+    case WKMediaCaptureTypeMicrophone:
+      kind = BUNITE_PERMISSION_MICROPHONE; break;
+    case WKMediaCaptureTypeCameraAndMicrophone:
+      kind = BUNITE_PERMISSION_CAMERA | BUNITE_PERMISSION_MICROPHONE; break;
+  }
+
+  if (!bunite_mac::g_runtime.pending_permissions) {
+    bunite_mac::g_runtime.pending_permissions = [NSMutableDictionary dictionary];
+  }
+  uint32_t request_id = bunite_mac::g_runtime.next_permission_request_id++;
+  BunitePendingPermission* entry = [[BunitePendingPermission alloc] init];
+  entry.viewId = view_id;
+  entry.handler = decisionHandler;
+  bunite_mac::g_runtime.pending_permissions[@(request_id)] = entry;
+
+  NSString* origin_str = origin.port != 0
+    ? [NSString stringWithFormat:@"%@://%@:%ld", origin.protocol, origin.host, (long)origin.port]
+    : [NSString stringWithFormat:@"%@://%@", origin.protocol, origin.host];
+  std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+    ",\"kind\":" + std::to_string(kind) +
+    ",\"url\":\"" + bunite_mac::escapeJsonString(origin_str.UTF8String ?: "") + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "permission-requested", payload);
+}
+
+@end
+
+namespace {
+
+// __weak NSMapTable so we don't retain WKWebViews via the lookup table.
+NSMapTable<WKWebView*, NSNumber*>* webviewIdTable() {
+  static NSMapTable* t = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory
+                                               valueOptions:NSPointerFunctionsStrongMemory];
+  return t;
+}
+
+} // namespace
+
+namespace bunite_mac {
+
+ViewState* findView(uint32_t view_id) {
+  std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+  auto it = g_runtime.views.find(view_id);
+  return it == g_runtime.views.end() ? nullptr : &it->second;
+}
+
+uint32_t viewIdForWebView(WKWebView* wv) {
+  NSNumber* id = [webviewIdTable() objectForKey:wv];
+  return id ? id.unsignedIntValue : 0;
+}
+
+bool createView(uint32_t view_id, uint32_t window_id,
+                NSString* url, NSString* html, NSString* preload, NSString* appres_root,
+                NSString* navigation_rules_json, NSString* preload_origins_json,
+                double x, double y, double width, double height, bool auto_resize) {
+  WindowState* window_state = findWindow(window_id);
+  if (!window_state) {
+    BUNITE_WARN("bunite_view_create: window %u not found.", window_id);
+    return false;
+  }
+  if (findView(view_id)) {
+    BUNITE_WARN("bunite_view_create: view %u already exists.", view_id);
+    return false;
+  }
+
+  WKWebViewConfiguration* config = [[WKWebViewConfiguration alloc] init];
+  [config setURLSchemeHandler:sharedAppresSchemeHandler() forURLScheme:@"appres"];
+  // popup_blocking=true → block popups without user gesture (default).
+  config.preferences.javaScriptCanOpenWindowsAutomatically = !g_runtime.popup_blocking;
+
+  if (preload.length > 0) {
+    // WKUserScript has no per-origin filter — gate in-script so remote pages don't inherit RPC bridge + secret.
+    NSString* origins = preload_origins_json.length > 0 ? preload_origins_json : @"[]";
+    NSString* gated = [NSString stringWithFormat:
+      @"(function(){"
+      @"  var _o=%@;_o.push('appres://app.internal');"
+      @"  if(_o.indexOf(location.origin)<0)return;"
+      @"  %@"
+      @"})();", origins, preload];
+    WKUserScript* script = [[WKUserScript alloc] initWithSource:gated
+                                                  injectionTime:WKUserScriptInjectionTimeAtDocumentStart
+                                               forMainFrameOnly:YES];
+    [config.userContentController addUserScript:script];
+  }
+
+  // auto_resize=true: logical points (main view). auto_resize=false: physical pixels (surface, JS × DPR).
+  NSRect frame;
+  if (auto_resize) {
+    frame = NSMakeRect(x, y, width, height);
+  } else {
+    CGFloat dpr = window_state->window.backingScaleFactor ?: 1.0;
+    frame = NSMakeRect(x / dpr, y / dpr, width / dpr, height / dpr);
+  }
+  BunitePassthroughContainer* container = [[BunitePassthroughContainer alloc] initWithFrame:frame];
+  container.wantsLayer = YES;  // enable CAShapeLayer mask (set_mask_region)
+
+  WKWebView* wv = [[WKWebView alloc] initWithFrame:container.bounds configuration:config];
+  wv.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  // DevTools off by default — bunite_view_open_devtools toggles via setInspectable.
+  if (@available(macOS 13.3, *)) wv.inspectable = NO;
+
+  static __strong BuniteNavigationDelegate* navDelegate = [[BuniteNavigationDelegate alloc] init];
+  static __strong BuniteUIDelegate* uiDelegate = [[BuniteUIDelegate alloc] init];
+  wv.navigationDelegate = navDelegate;
+  wv.UIDelegate = uiDelegate;
+
+  [container addSubview:wv];
+  [window_state->window.contentView addSubview:container];
+  if (auto_resize) container.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& st = g_runtime.views[view_id];
+    st.container = container;
+    st.webview = wv;
+    st.nav_delegate = navDelegate;
+    st.ui_delegate = uiDelegate;
+    st.window_id = window_id;
+    st.appres_root = appres_root.length > 0 ? appres_root.UTF8String : "";
+    st.preload_script = preload.length > 0 ? preload.UTF8String : "";
+    st.navigation_rules = parseNavigationRulesJson(navigation_rules_json);
+  }
+  [webviewIdTable() setObject:@(view_id) forKey:wv];
+
+  if (url.length > 0) {
+    NSURL* u = [NSURL URLWithString:url];
+    if (u) [wv loadRequest:[NSURLRequest requestWithURL:u]];
+  } else if (html.length > 0) {
+    [wv loadHTMLString:html baseURL:nil];
+  }
+
+  emitWebviewEvent(view_id, "view-ready", "");
+  return true;
+}
+
+void removeView(uint32_t view_id) {
+  __strong WKWebView* wv = nil;
+  __strong NSView* container = nil;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.views.find(view_id);
+    if (it == g_runtime.views.end()) return;
+    wv = it->second.webview;
+    container = it->second.container;
+    g_runtime.views.erase(it);
+  }
+  bunite::WebviewContentStorage::instance().remove(view_id);
+
+  // WebKit may not call stopURLSchemeTask during teardown — fail in-flight tasks here.
+  if (g_runtime.pending_route_tasks.count > 0) {
+    NSMutableArray<NSNumber*>* keys = [NSMutableArray array];
+    NSMutableArray<id<WKURLSchemeTask>>* victims = [NSMutableArray array];
+    for (NSNumber* key in g_runtime.pending_route_tasks) {
+      BunitePendingRoute* p = g_runtime.pending_route_tasks[key];
+      if (p.viewId == view_id) { [keys addObject:key]; [victims addObject:p.task]; }
+    }
+    [g_runtime.pending_route_tasks removeObjectsForKeys:keys];
+    NSError* err = [NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorCancelled userInfo:nil];
+    @try {
+      for (id<WKURLSchemeTask> t in victims) [t didFailWithError:err];
+    } @catch (NSException* e) {
+      // Race: WebKit may stop the task between snapshot and failure — swallow.
+    }
+  }
+
+  // Deny pending permissions — releases the handler block, unblocks JS waiters.
+  NSArray<BunitePendingPermission*>* to_deny = nil;
+  if (g_runtime.pending_permissions.count > 0) {
+    NSMutableArray<NSNumber*>* keys = [NSMutableArray array];
+    NSMutableArray<BunitePendingPermission*>* victims = [NSMutableArray array];
+    for (NSNumber* key in g_runtime.pending_permissions) {
+      BunitePendingPermission* p = g_runtime.pending_permissions[key];
+      if (p.viewId == view_id) { [keys addObject:key]; [victims addObject:p]; }
+    }
+    [g_runtime.pending_permissions removeObjectsForKeys:keys];
+    to_deny = victims;
+  }
+  if (@available(macOS 12.0, *)) {
+    for (BunitePendingPermission* p in to_deny) p.handler(WKPermissionDecisionDeny);
+  }
+
+  if (wv) [webviewIdTable() removeObjectForKey:wv];
+  if (container) [container removeFromSuperview];
+}
+
+} // namespace bunite_mac