bunite-core 0.14.0 → 0.16.0

package/src/host/native.ts

@@ -126,6 +126,26 @@ type NativeSymbols = {
   bunite_view_screenshot: (
     viewId: number, requestId: number, format: CStringPointer, quality: number
   ) => void;
+  bunite_view_accessibility_snapshot: (
+    viewId: number, requestId: number, interestingOnly: number
+  ) => void;
+  bunite_view_list_frames: (viewId: number, requestId: number) => void;
+  bunite_view_evaluate_in_frame: (
+    viewId: number, requestId: number, script: CStringPointer, frameId: CStringPointer
+  ) => void;
+  bunite_view_resolve_and_click: (
+    viewId: number, requestId: number,
+    selector: CStringPointer, frameId: CStringPointer,
+    button: number, clickCount: number, modifiers: number
+  ) => void;
+  bunite_view_set_download_policy: (
+    viewId: number, policy: number, downloadDir: CStringPointer
+  ) => void;
+  bunite_view_popup_accept: (
+    newViewId: number, hostWindowId: number,
+    x: number, y: number, w: number, h: number,
+  ) => void;
+  bunite_view_popup_dismiss: (newViewId: number) => void;
   bunite_view_capabilities: (viewId: number) => number;
   bunite_view_load_url: (viewId: number, url: CStringPointer) => void;
   bunite_view_load_html: (viewId: number, html: CStringPointer) => void;
@@ -342,6 +362,34 @@ const nativeSymbolDefinitions = {
     args: [FFIType.u32, FFIType.u32, FFIType.cstring, FFIType.i32],
     returns: FFIType.void
   },
+  bunite_view_accessibility_snapshot: {
+    args: [FFIType.u32, FFIType.u32, FFIType.i32],
+    returns: FFIType.void
+  },
+  bunite_view_list_frames: {
+    args: [FFIType.u32, FFIType.u32],
+    returns: FFIType.void
+  },
+  bunite_view_evaluate_in_frame: {
+    args: [FFIType.u32, FFIType.u32, FFIType.cstring, FFIType.cstring],
+    returns: FFIType.void
+  },
+  bunite_view_resolve_and_click: {
+    args: [FFIType.u32, FFIType.u32, FFIType.cstring, FFIType.cstring, FFIType.i32, FFIType.i32, FFIType.u32],
+    returns: FFIType.void
+  },
+  bunite_view_set_download_policy: {
+    args: [FFIType.u32, FFIType.i32, FFIType.cstring],
+    returns: FFIType.void
+  },
+  bunite_view_popup_accept: {
+    args: [FFIType.u32, FFIType.u32, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
+    returns: FFIType.void
+  },
+  bunite_view_popup_dismiss: {
+    args: [FFIType.u32],
+    returns: FFIType.void
+  },
   bunite_view_capabilities: {
     args: [FFIType.u32],
     returns: FFIType.u32
@@ -421,6 +469,61 @@ export function setScreenshotResultHandler(handler: (viewId: number, result: Nat
   screenshotResultHandler = handler;
 }
 
+export type NativeAccessibilityResult = {
+  requestId: number;
+  ok: boolean;
+  tree?: unknown;       // CDP Accessibility.AXNode tree as JSON value
+  code?: string;
+  message?: string;
+};
+let accessibilityResultHandler: ((viewId: number, result: NativeAccessibilityResult) => void) | null = null;
+export function setAccessibilityResultHandler(handler: (viewId: number, result: NativeAccessibilityResult) => void) {
+  accessibilityResultHandler = handler;
+}
+
+export type NativeListFramesResult = {
+  requestId: number;
+  ok: boolean;
+  /** Raw CDP `Page.getFrameTree` result (`{frameTree: {frame, childFrames}}`). TS flattens. */
+  raw?: unknown;
+  code?: string;
+  message?: string;
+};
+let listFramesResultHandler: ((viewId: number, result: NativeListFramesResult) => void) | null = null;
+export function setListFramesResultHandler(handler: (viewId: number, result: NativeListFramesResult) => void) {
+  listFramesResultHandler = handler;
+}
+
+export type NativeResolveAndClickResult = {
+  requestId: number;
+  ok: boolean;
+  rect?: { x: number; y: number; width: number; height: number };
+  isTrustedEvent?: boolean;
+  code?: string;
+  message?: string;
+};
+let resolveAndClickResultHandler: ((viewId: number, result: NativeResolveAndClickResult) => void) | null = null;
+export function setResolveAndClickResultHandler(handler: (viewId: number, result: NativeResolveAndClickResult) => void) {
+  resolveAndClickResultHandler = handler;
+}
+
+export type NativeDownloadEvent = {
+  kind: "started" | "progress" | "completed" | "failed" | "blocked";
+  id: string;
+  url?: string;
+  suggestedFilename?: string;
+  mimeType?: string;
+  sizeBytes?: number;
+  receivedBytes?: number;
+  totalBytes?: number;
+  localPath?: string;
+  reason?: string;
+};
+let downloadEventHandler: ((viewId: number, event: NativeDownloadEvent) => void) | null = null;
+export function setDownloadEventHandler(handler: (viewId: number, event: NativeDownloadEvent) => void) {
+  downloadEventHandler = handler;
+}
+
 // Per-view deferred resolvers for "view-ready" (OnAfterCreated).
 const viewReadyResolvers = new Map<number, () => void>();
 
@@ -575,6 +678,42 @@ function registerNativeCallbacks(library: LoadedNativeLibrary) {
             screenshotResultHandler?.(viewId, parsed);
             break;
           }
+          case "accessibility-result": {
+            const parsed = maybeParsePayload(payload) as NativeAccessibilityResult;
+            accessibilityResultHandler?.(viewId, parsed);
+            break;
+          }
+          case "list-frames-result": {
+            const parsed = maybeParsePayload(payload) as NativeListFramesResult;
+            listFramesResultHandler?.(viewId, parsed);
+            break;
+          }
+          case "resolve-and-click-result": {
+            const parsed = maybeParsePayload(payload) as NativeResolveAndClickResult;
+            resolveAndClickResultHandler?.(viewId, parsed);
+            break;
+          }
+          case "download-event": {
+            const parsed = maybeParsePayload(payload) as NativeDownloadEvent;
+            downloadEventHandler?.(viewId, parsed);
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.downloadEvent(parsed),
+              viewId
+            );
+            break;
+          }
+          case "popup-requested": {
+            const parsed = maybeParsePayload(payload) as {
+              newSurfaceId: number;
+              url: string;
+              disposition: "tab" | "window" | "popup";
+            };
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.popupRequested(parsed),
+              viewId
+            );
+            break;
+          }
           case "title-changed": {
             const parsed = maybeParsePayload(payload) as { title: string };
             buniteEventEmitter.emitEvent(
@@ -779,7 +918,7 @@ export async function initNativeRuntime(
     throw new Error(`bunite: failed to load native library at ${artifacts.nativeLibPath}.`);
   }
 
-  const EXPECTED_ABI = 9;
+  const EXPECTED_ABI = 11;
   const nativeAbi = nativeLibrary.symbols.bunite_abi_version();
   if (nativeAbi !== EXPECTED_ABI) {
     throw new Error(

package/src/host/preloadBundle.ts

@@ -70,11 +70,16 @@ export function buildViewPreloadScript(options: {
 }) {
   const secretKeyBase64 = Buffer.from(options.secretKey).toString("base64");
 
-  // Per-view config — these globals are consumed by the pre-built runtime
+  // Per-view config — these globals are consumed by the pre-built runtime.
   const config = `var __buniteWebviewId=${options.webviewId},__buniteRpcSocketPort=${options.rpcSocketPort},__buniteSecretKeyBase64=${JSON.stringify(secretKeyBase64)};`;
 
   const runtime = getPreloadRuntime();
   const customPreload = readCustomPreload(options.preload, options.appresRoot).trim();
 
-  return [config, runtime, customPreload].filter(Boolean).join("\n");
+  // `;\n` between segments guards against ASI / token-boundary issues.
+  const inner = [config, runtime, customPreload].filter(Boolean).join(";\n");
+  // Catch top-level errors so a broken segment doesn't abort the surrounding
+  // native IIFE wrapper. Stashes the error on globalThis for programmatic
+  // inspection in addition to console.error.
+  return `try{${inner}\n}catch(e){try{globalThis.__bunitePreloadError=e}catch(_){}try{console.error("[bunite preload] failed:",e&&e.stack||e)}catch(_){}}`;
 }

package/src/native/linux/bunite_linux_ffi.cpp

@@ -356,6 +356,15 @@ extern "C" BUNITE_EXPORT void bunite_view_press(uint32_t, int32_t, int32_t, cons
 extern "C" BUNITE_EXPORT void bunite_view_scroll(uint32_t, double, double, double, double, uint32_t) {}
 extern "C" BUNITE_EXPORT void bunite_view_mouse(uint32_t, int32_t, double, double, int32_t, uint32_t) {}
 
+extern "C" BUNITE_EXPORT void bunite_view_resolve_and_click(
+    uint32_t view_id, uint32_t request_id, const char* /*selector*/, const char* /*frame_id*/,
+    int32_t /*button*/, int32_t /*click_count*/, uint32_t /*modifiers*/) {
+  std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                        ",\"ok\":false,\"code\":\"not_supported\","
+                        "\"message\":\"WebKitGTK has no synthetic input API\"}";
+  bunite_linux::emitWebviewEvent(view_id, "resolve-and-click-result", payload);
+}
+
 extern "C" BUNITE_EXPORT void bunite_view_respond_dialog(uint32_t view_id, uint32_t request_id,
                                                           bool accept, const char* text) {
   bunite_linux::respondToDialogRequest(view_id, request_id, accept, text ? text : "");
@@ -452,7 +461,202 @@ extern "C" BUNITE_EXPORT uint32_t bunite_view_capabilities(uint32_t view_id) {
   if (!v) return 0;
   return BUNITE_CAP_EVALUATE | BUNITE_CAP_SURFACE_EVENTS |
          BUNITE_CAP_DIALOGS | BUNITE_CAP_CONSOLE |
-         BUNITE_CAP_SCREENSHOT | BUNITE_CAP_FORMAT_PNG | BUNITE_CAP_FORMAT_JPEG;
+         BUNITE_CAP_SCREENSHOT | BUNITE_CAP_FORMAT_PNG | BUNITE_CAP_FORMAT_JPEG |
+         BUNITE_CAP_BOUNDING_RECT | BUNITE_CAP_DOWNLOADS | BUNITE_CAP_POPUPS |
+         BUNITE_CAP_AX | BUNITE_CAP_FRAMES;
+}
+
+namespace {
+
+struct AxCtx { uint32_t view_id; uint32_t request_id; };
+
+// JS-bridge ax tree: walks DOM + reads ARIA attrs. Emits CDP-shaped flat list
+// so TS-side convertAxTree works unchanged. `ignored` is always false — TS
+// `interestingOnly` filter is a no-op on this backend (limitation).
+const char* kAxScript = R"((function(){
+  var nodes=[];
+  function add(el,parentId){
+    if(!el||el.nodeType!==1)return null;
+    var id=String(nodes.length+1);
+    var node={nodeId:id,parentId:parentId,
+      role:{value:el.getAttribute('role')||el.tagName.toLowerCase()},
+      name:{value:el.getAttribute('aria-label')||
+        (el.tagName==='INPUT'||el.tagName==='TEXTAREA'?'':
+        (el.firstChild&&el.firstChild.nodeType===3?el.firstChild.textContent.trim().slice(0,100):''))},
+      properties:[],childIds:[],ignored:false};
+    var d=el.getAttribute('aria-description');if(d)node.description={value:d};
+    if(el.tagName==='INPUT'||el.tagName==='TEXTAREA'){if(el.value)node.value={value:el.value};}
+    if(el.getAttribute('aria-disabled')==='true'||el.disabled)node.properties.push({name:'disabled',value:{value:true}});
+    var ck=el.getAttribute('aria-checked');
+    if(ck==='true')node.properties.push({name:'checked',value:{value:true}});
+    else if(ck==='false')node.properties.push({name:'checked',value:{value:false}});
+    else if(ck==='mixed')node.properties.push({name:'checked',value:{value:'mixed'}});
+    var pr=el.getAttribute('aria-pressed');
+    if(pr==='true')node.properties.push({name:'pressed',value:{value:true}});
+    else if(pr==='false')node.properties.push({name:'pressed',value:{value:false}});
+    else if(pr==='mixed')node.properties.push({name:'pressed',value:{value:'mixed'}});
+    if(el.getAttribute('aria-expanded')==='true')node.properties.push({name:'expanded',value:{value:true}});
+    if(el.getAttribute('aria-selected')==='true')node.properties.push({name:'selected',value:{value:true}});
+    if(el.getAttribute('aria-required')==='true')node.properties.push({name:'required',value:{value:true}});
+    if(el.getAttribute('aria-invalid')==='true')node.properties.push({name:'invalid',value:{value:true}});
+    var lv=el.getAttribute('aria-level');if(lv)node.properties.push({name:'level',value:{value:parseInt(lv,10)}});
+    if(document.activeElement===el)node.properties.push({name:'focused',value:{value:true}});
+    nodes.push(node);
+    for(var i=0;i<el.children.length;i++){var cid=add(el.children[i],id);if(cid)node.childIds.push(cid);}
+    return id;
+  }
+  add(document.documentElement,null);
+  return JSON.stringify({nodes:nodes});
+})())";
+
+void on_ax_done(GObject* source, GAsyncResult* res, gpointer user_data) {
+  auto* ctx = static_cast<AxCtx*>(user_data);
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(source);
+  GError* err = nullptr;
+  JSCValue* value = webkit_web_view_evaluate_javascript_finish(wv, res, &err);
+  std::string payload = "{\"requestId\":" + std::to_string(ctx->request_id);
+  if (err || !value) {
+    std::string msg = err ? err->message : "evaluate failed";
+    if (err) g_error_free(err);
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"" + bunite_linux::escapeJsonString(msg) + "\"}";
+  } else if (!jsc_value_is_string(value)) {
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"non-string ax result\"}";
+  } else {
+    char* raw = jsc_value_to_string(value);
+    std::string tree_json = raw ? raw : "{}";
+    if (raw) g_free(raw);
+    payload += ",\"ok\":true,\"tree\":" + tree_json + "}";
+  }
+  if (value) g_object_unref(value);
+  bunite_linux::emitWebviewEvent(ctx->view_id, "accessibility-result", payload);
+  delete ctx;
+}
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT void bunite_view_accessibility_snapshot(uint32_t view_id, uint32_t request_id,
+                                                                  int32_t /*interesting_only*/) {
+  auto* st = bunite_linux::findView(view_id);
+  if (!st || !st->webview) {
+    std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                          ",\"ok\":false,\"code\":\"not_supported\","
+                          "\"message\":\"view not ready\"}";
+    bunite_linux::emitWebviewEvent(view_id, "accessibility-result", payload);
+    return;
+  }
+  auto* ctx = new AxCtx{view_id, request_id};
+  webkit_web_view_evaluate_javascript(st->webview, kAxScript, -1, nullptr, nullptr, nullptr, on_ax_done, ctx);
+}
+
+namespace {
+
+struct FramesCtx { uint32_t view_id; uint32_t request_id; };
+
+// JS-bridge frame tree: walks window.frames. Synthetic IDs are sequential —
+// not stable across calls. Cross-origin frames are included with empty url/origin
+// (SecurityError catch). Output matches CDP `Page.getFrameTree` shape so the
+// TS-side flattenFrameTree works unchanged.
+const char* kFramesScript = R"((function(){
+  var id=0;
+  function walk(win){
+    var fid=String(++id);
+    var frame={id:fid,securityOrigin:'',url:''};
+    try{
+      frame.url=win.location.href;
+      frame.securityOrigin=win.location.origin;
+      if(win.frameElement&&win.frameElement.name)frame.name=win.frameElement.name;
+    }catch(e){}
+    var children=[];
+    try{for(var i=0;i<win.frames.length;i++)children.push(walk(win.frames[i]));}catch(e){}
+    return {frame:frame,childFrames:children};
+  }
+  return JSON.stringify({frameTree:walk(window)});
+})())";
+
+void on_frames_done(GObject* source, GAsyncResult* res, gpointer user_data) {
+  auto* ctx = static_cast<FramesCtx*>(user_data);
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(source);
+  GError* err = nullptr;
+  JSCValue* value = webkit_web_view_evaluate_javascript_finish(wv, res, &err);
+  std::string payload = "{\"requestId\":" + std::to_string(ctx->request_id);
+  if (err || !value) {
+    std::string msg = err ? err->message : "evaluate failed";
+    if (err) g_error_free(err);
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"" + bunite_linux::escapeJsonString(msg) + "\"}";
+  } else if (!jsc_value_is_string(value)) {
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"non-string frames result\"}";
+  } else {
+    char* raw = jsc_value_to_string(value);
+    std::string tree_json = raw ? raw : "{}";
+    if (raw) g_free(raw);
+    payload += ",\"ok\":true,\"raw\":" + tree_json + "}";
+  }
+  if (value) g_object_unref(value);
+  bunite_linux::emitWebviewEvent(ctx->view_id, "list-frames-result", payload);
+  delete ctx;
+}
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT void bunite_view_list_frames(uint32_t view_id, uint32_t request_id) {
+  auto* st = bunite_linux::findView(view_id);
+  if (!st || !st->webview) {
+    std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                          ",\"ok\":false,\"code\":\"not_supported\","
+                          "\"message\":\"view not ready\"}";
+    bunite_linux::emitWebviewEvent(view_id, "list-frames-result", payload);
+    return;
+  }
+  auto* ctx = new FramesCtx{view_id, request_id};
+  webkit_web_view_evaluate_javascript(st->webview, kFramesScript, -1, nullptr, nullptr, nullptr, on_frames_done, ctx);
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_evaluate_in_frame(uint32_t view_id, uint32_t request_id,
+                                                              const char* script_c, const char* frame_id_c) {
+  std::string script = script_c ? script_c : "";
+  std::string frame_id = frame_id_c ? frame_id_c : "";
+  if (frame_id.empty()) {
+    bunite_view_evaluate(view_id, request_id, script_c);
+    return;
+  }
+  // JS-bridge: walk window.frames matching listFrames numbering, `eval` user
+  // script in target frame. frameIds are sequential per walk — caller must use
+  // them immediately after listFrames. The outer envelope from
+  // bunite_view_evaluate handles ok/cross_origin/runtime_error mapping; we
+  // surface SecurityError so cross-origin → cross_origin and re-throw missing
+  // frames as plain Error → runtime_error.
+  std::string js_target = bunite_linux::escapeJsonString(frame_id);
+  std::string js_script = bunite_linux::escapeJsonString(script);
+  std::string inner =
+    "(function(){var target=\"" + js_target + "\";var id=0;var found=null;"
+    "function walk(win){var fid=String(++id);if(fid===target){found=win;return;}"
+    "try{for(var i=0;i<win.frames.length;i++){walk(win.frames[i]);if(found)return;}}catch(e){}}"
+    "walk(window);"
+    "if(!found)throw new Error('frame not found');"
+    "return found.eval(\"(\"+\"" + js_script + "\"+\")\");"
+    "})()";
+  bunite_view_evaluate(view_id, request_id, inner.c_str());
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_download_policy(uint32_t view_id, int32_t policy, const char* download_dir) {
+  auto* st = bunite_linux::findView(view_id);
+  if (!st) return;
+  if (policy < 0 || policy > 2) policy = 2;
+  st->download_policy.store(policy);
+  st->download_dir = download_dir ? download_dir : "";
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_popup_accept(uint32_t new_view_id, uint32_t host_window_id,
+                                                       double x, double y, double w, double h) {
+  runOnUiThreadSync([=]() { bunite_linux::acceptParkedPopup(new_view_id, host_window_id, x, y, w, h); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_popup_dismiss(uint32_t new_view_id) {
+  runOnUiThreadSync([=]() { bunite_linux::dismissParkedPopup(new_view_id); });
 }
 
 extern "C" BUNITE_EXPORT void bunite_view_screenshot(uint32_t view_id, uint32_t request_id,

package/src/native/linux/bunite_linux_internal.h

@@ -43,6 +43,10 @@ struct ViewState {
   // held until we mark confirmed/text + emit signal completion.
   std::unordered_map<uint32_t, WebKitScriptDialog*> pending_dialogs;
   uint32_t next_dialog_request_id = 1;
+
+  // Download policy: 0=auto, 1=ask (treated as block), 2=block (default).
+  std::atomic<int32_t> download_policy{2};
+  std::string download_dir;
 };
 
 struct RuntimeState {
@@ -59,6 +63,12 @@ struct RuntimeState {
   pthread_t ui_thread = 0;
   bool ui_thread_set = false;
 
+  // Hidden top-level window — popup-minted WebViews park here until adoption.
+  GtkWindow* popup_parent = nullptr;
+  // Parked popup-minted views awaiting acceptPopup/dismissPopup. Keyed by
+  // popup view_id (>= 0x80000000).
+  std::unordered_map<uint32_t, WebKitWebView*> parked_popups;
+
   std::unordered_map<uint32_t, WebKitPermissionRequest*> pending_permissions;
   uint32_t next_permission_request_id = 1;
 
@@ -147,6 +157,8 @@ bool createView(uint32_t view_id, uint32_t window_id,
 void removeView(uint32_t view_id);
 void detachViewSideState(uint32_t view_id);
 void applyViewBounds(uint32_t view_id, double x, double y, double width, double height);
+bool acceptParkedPopup(uint32_t new_view_id, uint32_t host_window_id, double x, double y, double w, double h);
+void dismissParkedPopup(uint32_t new_view_id);
 void queueViewRedraw(WebKitWebView* wv);
 
 void registerAppresScheme(WebKitWebContext* ctx);

package/src/native/linux/bunite_linux_runtime.cpp

@@ -16,7 +16,7 @@ bool isOnMainThread() {
 
 namespace {
 
-constexpr int32_t kBuniteAbiVersion = 9;
+constexpr int32_t kBuniteAbiVersion = 11;
 
 }  // namespace
 
@@ -59,6 +59,11 @@ extern "C" BUNITE_EXPORT bool bunite_init(
   }
 
   rt.app = app;
+  // Hidden offscreen parent — popup-minted views park here until host adoption.
+  rt.popup_parent = GTK_WINDOW(gtk_window_new());
+  gtk_window_set_decorated(rt.popup_parent, FALSE);
+  gtk_window_set_default_size(rt.popup_parent, 1, 1);
+  gtk_window_set_child(rt.popup_parent, gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
   rt.initialized = true;
   return true;
 }