bunite-core 0.12.1 → 0.16.0

package/src/webview/native.ts

@@ -1,7 +1,15 @@
 // <bunite-webview> custom element — registered in every appres:// page via preload.
 
 import type { ClientOf } from "../rpc/index";
-import type { SurfaceCap, EvaluateResult, SurfaceCapabilities } from "../rpc/framework";
+import type {
+  SurfaceCap, EvaluateResult, SurfaceCapabilities, ScreenshotResult,
+  SurfaceEvent, ConsoleEntry, WaitResult, NavigationState,
+  AccessibilitySnapshotResult, BoundingRectResult, ListFramesResult,
+  DownloadEvent, DownloadPolicy, WaitForDownloadResult,
+  ResolveAndClickResult,
+} from "../rpc/framework";
+
+declare const __buniteWebviewId: number;
 
 declare const host: {
   runtime(): Promise<ClientOf<typeof import("../rpc/framework").RuntimeCap>>;
@@ -136,40 +144,51 @@ class BuniteWebviewElement extends HTMLElement {
     void (async () => {
       try {
         const s = await getSurfaceCap();
-        const stream = s.didNavigate();
-        this._activeStreams.push(stream as { cancel?: () => void });
-        for await (const ev of stream) {
-          if (ctrl.signal.aborted) break;
-          if (ev.surfaceId === this._surfaceId) {
-            this.dispatchEvent(new CustomEvent("did-navigate", { detail: { url: ev.url } }));
-          }
-        }
-      } catch (err) {
-        if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
-          console.warn("[bunite] didNavigate stream failed", err);
-        }
-      }
-    })();
-    void (async () => {
-      try {
-        const s = await getSurfaceCap();
-        const stream = s.titleChanged();
-        this._activeStreams.push(stream as { cancel?: () => void });
-        for await (const ev of stream) {
+        if (ctrl.signal.aborted) return;
+        await this._waitForSurfaceId(ctrl.signal);
+        const sid = this._surfaceId;
+        if (ctrl.signal.aborted || sid == null) return;
+        const surfStream = s.surfaceEvents({ surfaceId: sid });
+        this._activeStreams.push(surfStream as { cancel?: () => void });
+        const dlStream = s.downloadEvents({ surfaceId: sid });
+        this._activeStreams.push(dlStream as { cancel?: () => void });
+        (async () => {
+          try {
+            for await (const event of dlStream) {
+              if (ctrl.signal.aborted) break;
+              this.dispatchEvent(new CustomEvent<DownloadEvent>("download-event", { detail: event }));
+            }
+          } catch { /* stream torn down */ }
+        })();
+        for await (const event of surfStream) {
           if (ctrl.signal.aborted) break;
-          if (ev.surfaceId === this._surfaceId) {
-            this.dispatchEvent(new CustomEvent("title-changed", { detail: { title: ev.title } }));
-          }
+          this.dispatchEvent(new CustomEvent<SurfaceEvent>("surface-event", { detail: event }));
         }
       } catch (err) {
         if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
-          console.warn("[bunite] titleChanged stream failed", err);
+          console.warn("[bunite] surfaceEvents stream failed", err);
         }
       }
     })();
     this._waitForLayout();
   }
 
+  private async _waitForSurfaceId(signal: AbortSignal): Promise<void> {
+    while (this._surfaceId == null && !signal.aborted) {
+      const pending = this._initPromise;
+      if (pending) {
+        // Await this exact init attempt; if it rejects, bail (init failed —
+        // we'd otherwise spin forever waiting for a surfaceId that never lands).
+        try { await pending; } catch { return; }
+        // After resolve, _surfaceId may still be null if disconnect raced —
+        // the next loop iteration checks signal.aborted to exit cleanly.
+      } else {
+        // No init in flight yet (waiting for layout). Yield then re-check.
+        await new Promise((r) => setTimeout(r, 16));
+      }
+    }
+  }
+
   private _waitForLayout() {
     if (this._layoutObserver) return; // already waiting
 
@@ -257,24 +276,168 @@ class BuniteWebviewElement extends HTMLElement {
     this.setAttribute("src", url);
   }
 
-  async evaluate(script: string): Promise<EvaluateResult> {
+  async evaluate(script: string, opts?: { frameId?: string }): Promise<EvaluateResult> {
     const sid = this._surfaceId;
     if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
-    return callSurfaceTyped((s) => s.evaluate({ surfaceId: sid, script }));
+    return callSurfaceTyped((s) => s.evaluate({ surfaceId: sid, script, frameId: opts?.frameId }));
   }
 
   async capabilities(): Promise<SurfaceCapabilities> {
     const sid = this._surfaceId;
     if (sid == null) {
       return {
-        evaluate: false, crossOriginEval: false, titleChanged: false,
+        evaluate: false, crossOriginEval: false, surfaceEvents: false,
         nativeInputTrusted: false, click: false, type: false, press: false,
-        scroll: false, screenshot: false,
+        scroll: false, mouse: false, dialogs: false, console: false,
+        screenshot: false, accessibilitySnapshot: false, getBoundingRect: false,
+        frames: false, downloads: false, popups: false, resolveAndClick: false,
       };
     }
     return callSurfaceTyped((s) => s.capabilities({ surfaceId: sid }));
   }
 
+  // Automation input — `send*` prefix avoids clashing with HTMLElement.click() / .scroll().
+  async sendClick(args: {
+    x: number; y: number;
+    button?: "left" | "middle" | "right";
+    clickCount?: number;
+    modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">;
+  }): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.click({ surfaceId: sid, ...args }));
+  }
+
+  async sendType(text: string): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.type({ surfaceId: sid, text }));
+  }
+
+  async sendPress(
+    key: string,
+    modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">,
+    action?: "down" | "up" | "both"
+  ): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.press({ surfaceId: sid, key, modifiers, action }));
+  }
+
+  async sendScroll(args: {
+    dx: number; dy: number; x?: number; y?: number;
+    modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">;
+  }): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.scroll({ surfaceId: sid, ...args }));
+  }
+
+  async sendMouse(args: {
+    action: "move" | "down" | "up";
+    x: number; y: number;
+    button?: "left" | "middle" | "right";
+    modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">;
+  }): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.mouse({ surfaceId: sid, ...args }));
+  }
+
+  async respondToDialog(requestId: number, accept: boolean, text?: string): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.respondToDialog({ surfaceId: sid, requestId, accept, text }));
+  }
+
+  async setDialogTimeout(ms: number | null): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurfaceTyped((s) => s.setDialogTimeout({ surfaceId: sid, ms }));
+  }
+
+  async waitForSelector(selector: string, timeoutMs?: number): Promise<WaitResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.waitForSelector({ surfaceId: sid, selector, timeoutMs }));
+  }
+
+  async waitForFunction(expression: string, opts?: { timeoutMs?: number; pollIntervalMs?: number }): Promise<WaitResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.waitForFunction({ surfaceId: sid, expression, ...opts }));
+  }
+
+  async getConsoleBuffer(opts?: { clear?: boolean }): Promise<ConsoleEntry[]> {
+    const sid = this._surfaceId;
+    if (sid == null) return [];
+    return (await callSurfaceTyped((s) => s.getConsoleBuffer({ surfaceId: sid, clear: opts?.clear }))) ?? [];
+  }
+
+  async getNavigationState(): Promise<NavigationState> {
+    const sid = this._surfaceId;
+    if (sid == null) return { lastLoadEpoch: 0, isLoading: false, currentUrl: "" };
+    return callSurfaceTyped((s) => s.getNavigationState({ surfaceId: sid }));
+  }
+
+  async accessibilitySnapshot(opts?: { interestingOnly?: boolean }): Promise<AccessibilitySnapshotResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.accessibilitySnapshot({ surfaceId: sid, interestingOnly: opts?.interestingOnly }));
+  }
+
+  async getBoundingRect(selector: string, opts?: { frameId?: string }): Promise<BoundingRectResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.getBoundingRect({ surfaceId: sid, selector, frameId: opts?.frameId }));
+  }
+
+  async listFrames(): Promise<ListFramesResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.listFrames({ surfaceId: sid }));
+  }
+
+  async resolveAndClick(
+    selector: string,
+    opts?: {
+      frameId?: string;
+      button?: "left" | "middle" | "right";
+      clickCount?: number;
+      modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">;
+    }
+  ): Promise<ResolveAndClickResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.resolveAndClick({ surfaceId: sid, selector, ...opts }));
+  }
+
+  async setDownloadPolicy(policy: DownloadPolicy, downloadDir?: string): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurface((s) => s.setDownloadPolicy({ surfaceId: sid, policy, downloadDir }));
+  }
+
+  async waitForDownload(opts?: { timeoutMs?: number }): Promise<WaitForDownloadResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.waitForDownload({ surfaceId: sid, timeoutMs: opts?.timeoutMs }));
+  }
+
+  async dismissPopup(newSurfaceId: number): Promise<void> {
+    await callSurface((s) => s.dismissPopup({ newSurfaceId }));
+  }
+
+  async extendAdoptionTimeout(newSurfaceId: number, gracePeriodMs: number) {
+    return callSurfaceTyped((s) => s.extendPopupTimeout({ newSurfaceId, gracePeriodMs }));
+  }
+
+  async screenshot(args?: { format?: "png" | "jpeg"; quality?: number }): Promise<ScreenshotResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.screenshot({ surfaceId: sid, ...args }));
+  }
+
   private _applySurfaceHidden() {
     const sid = this._surfaceId;
     if (sid == null) return;
@@ -282,11 +445,71 @@ class BuniteWebviewElement extends HTMLElement {
     void callSurface((s) => s.setHidden({ surfaceId: sid, hidden }));
   }
 
+  private _setupSyncCtrl() {
+    this._syncCtrl = new OverlaySyncController(this, (rect) => {
+      const sid = this._surfaceId;
+      if (sid == null) return;
+      const isZero = rect.width === 0 && rect.height === 0;
+      if (isZero) {
+        if (!this._syncHidden) {
+          this._syncHidden = true;
+          this._applySurfaceHidden();
+        }
+        return;
+      }
+      if (this._syncHidden) {
+        this._syncHidden = false;
+        this._applySurfaceHidden();
+      }
+      void callSurface((s) => s.resize({
+        surfaceId: sid, x: rect.x, y: rect.y, w: rect.width, h: rect.height,
+      }));
+    });
+    this._syncCtrl.start();
+  }
+
   private initSurface() {
     if (this._surfaceId != null || this._initPromise != null) return;
 
     const dpr = window.devicePixelRatio || 1;
     const r = this.getBoundingClientRect();
+    const adoptAttr = this.getAttribute("adopt-popup-id");
+    const adoptId = adoptAttr ? Number(adoptAttr) : NaN;
+    if (Number.isFinite(adoptId)) {
+      // Popup adoption — bind a backend-minted surface (received via the parent
+      // page's `surface-event` `popup` arm) to this element.
+      const initPromise = getSurfaceCap().then(async (s) => {
+        const res = await s.acceptPopup({
+          newSurfaceId: adoptId,
+          hostViewId: __buniteWebviewId,
+          bounds: {
+            x: Math.round(r.x * dpr),
+            y: Math.round(r.y * dpr),
+            width: Math.round(r.width * dpr),
+            height: Math.round(r.height * dpr),
+          },
+        });
+        if (!res.ok) throw new Error(`acceptPopup failed: ${res.code}: ${res.message}`);
+        return { surfaceId: adoptId };
+      }) as Promise<SurfaceInitResponse>;
+      this._initPromise = initPromise;
+      initPromise.then((response) => {
+        if (this._initPromise !== initPromise) return;
+        if (this._aborted) {
+          void callSurface((s) => s.remove({ surfaceId: response.surfaceId }));
+          return;
+        }
+        this._surfaceId = response.surfaceId;
+        this._setupSyncCtrl();
+      }).catch((err) => {
+        if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
+          console.warn("[bunite] adopt-popup-id init failed", err);
+        }
+        this._initPromise = null;
+      });
+      return;
+    }
+
     const src = this._pendingSrc || this.getAttribute("src") || "";
     this._pendingSrc = null;
 
@@ -323,28 +546,7 @@ class BuniteWebviewElement extends HTMLElement {
           }
         }
 
-        this._syncCtrl = new OverlaySyncController(this, (rect) => {
-          const sid = this._surfaceId;
-          if (sid == null) return;
-
-          const isZero = rect.width === 0 && rect.height === 0;
-          if (isZero) {
-            if (!this._syncHidden) {
-              this._syncHidden = true;
-              this._applySurfaceHidden();
-            }
-            return;
-          }
-          if (this._syncHidden) {
-            this._syncHidden = false;
-            this._applySurfaceHidden();
-          }
-
-          void callSurface((s) => s.resize({
-            surfaceId: sid, x: rect.x, y: rect.y, w: rect.width, h: rect.height,
-          }));
-        });
-        this._syncCtrl.start();
+        this._setupSyncCtrl();
       })
       .catch(() => {})
       .finally(() => {