@dev-blinq/cucumber_client 1.0.1624-dev → 1.0.1625-dev

package/bin/client/recorderv3/bvt_init.js

@@ -327,10 +327,14 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
       console.log("Received browserUI.goForward", input);
       await recorder.goForward(input);
     },
-    "browserUI.clipboardWrite": async (input) => {
-      console.log("Received browserUI.clipboardWrite");
+    "browserUI.writeToClipboard": async (input) => {
+      console.log("Received browserUI.writeToClipboard");
       await recorder.applyClipboardPayload(input);
     },
+    "browserUI.readToClipboard": async (input) => {
+      console.log("Received browserUI.readToClipboard");
+      await recorder.readClipboardPayload(input);
+    },
     "recorderWindow.cleanup": async (input) => {
       return recorder.cleanup(input);
     },

package/bin/client/recorderv3/bvt_recorder.js

@@ -7,8 +7,7 @@ import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
 import { NamesService, RemoteBrowserService, PublishService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
 import { readFile, writeFile } from "fs/promises";
-import { updateStepDefinitions, loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
-import { updateFeatureFile } from "./update_feature.js";
+import { loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
@@ -18,37 +17,36 @@ import socketLogger from "../utils/socket_logger.js";
 import { tmpdir } from "os";
 import { faker } from "@faker-js/faker/locale/en_US";
 import { chromium } from "playwright-core";
+
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export function getInitScript(config, options) {
-  const preScript = `
-  window.__bvt_Recorder_config = ${JSON.stringify(config ?? null)};
-  window.__PW_options = ${JSON.stringify(options ?? null)};
-  `;
-  const recorderScript = readFileSync(
-    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
-    "utf8"
-  );
-  const clipboardBridgeScript = `
+
+const clipboardBridgeScript = `
   ;(() => {
     if (window.__bvtRecorderClipboardBridgeInitialized) {
+      console.log('[ClipboardBridge] Already initialized, skipping');
       return;
     }
     window.__bvtRecorderClipboardBridgeInitialized = true;
+    console.log('[ClipboardBridge] Initializing clipboard bridge');
 
     const emitPayload = (payload, attempt = 0) => {
       const reporter = window.__bvt_reportClipboard;
       if (typeof reporter === "function") {
         try {
+          console.log('[ClipboardBridge] Reporting clipboard payload:', payload);
           reporter(payload);
         } catch (error) {
-          console.warn("Clipboard bridge failed to report payload", error);
+          console.warn("[ClipboardBridge] Failed to report payload", error);
         }
         return;
       }
       if (attempt < 5) {
+        console.log('[ClipboardBridge] Reporter not ready, retrying...', attempt);
         setTimeout(() => emitPayload(payload, attempt + 1), 50 * (attempt + 1));
+      } else {
+        console.warn('[ClipboardBridge] Reporter never became available');
       }
     };
 
@@ -78,7 +76,7 @@ export function getInitScript(config, options) {
           reader.onerror = () => resolve(null);
           reader.readAsDataURL(file);
         } catch (error) {
-          console.warn("Clipboard bridge failed to serialize file", error);
+          console.warn("[ClipboardBridge] Failed to serialize file", error);
           resolve(null);
         }
       });
@@ -86,6 +84,7 @@ export function getInitScript(config, options) {
 
     const handleClipboardEvent = async (event) => {
       try {
+        console.log('[ClipboardBridge] Handling clipboard event:', event.type);
         const payload = { trigger: event.type };
         const clipboardData = event.clipboardData;
 
@@ -94,22 +93,25 @@ export function getInitScript(config, options) {
             const text = clipboardData.getData("text/plain");
             if (text) {
               payload.text = text;
+              console.log('[ClipboardBridge] Captured text:', text.substring(0, 50));
             }
           } catch (error) {
-            console.warn("Clipboard bridge could not read text/plain", error);
+            console.warn("[ClipboardBridge] Could not read text/plain", error);
           }
 
           try {
             const html = clipboardData.getData("text/html");
             if (html) {
               payload.html = html;
+              console.log('[ClipboardBridge] Captured HTML:', html.substring(0, 50));
             }
           } catch (error) {
-            console.warn("Clipboard bridge could not read text/html", error);
+            console.warn("[ClipboardBridge] Could not read text/html", error);
           }
 
           const files = clipboardData.files;
           if (files && files.length > 0) {
+            console.log('[ClipboardBridge] Processing files:', files.length);
             const serialized = [];
             for (const file of files) {
               const data = await fileToBase64(file);
@@ -134,6 +136,7 @@ export function getInitScript(config, options) {
             const selectionText = selection?.toString?.();
             if (selectionText) {
               payload.text = selectionText;
+              console.log('[ClipboardBridge] Using selection text:', selectionText.substring(0, 50));
             }
           } catch {
             // Ignore selection access errors.
@@ -142,10 +145,170 @@ export function getInitScript(config, options) {
 
         emitPayload(payload);
       } catch (error) {
-        console.warn("Clipboard bridge could not process event", error);
+        console.warn("[ClipboardBridge] Could not process event", error);
       }
     };
 
+    // NEW: Function to apply clipboard data to the page
+    window.__bvt_applyClipboardData = (payload) => {
+      console.log('[ClipboardBridge] Applying clipboard data:', payload);
+      
+      if (!payload) {
+        console.warn('[ClipboardBridge] No payload provided');
+        return false;
+      }
+      
+      try {
+        // Create DataTransfer object
+        let dataTransfer = null;
+        try {
+          dataTransfer = new DataTransfer();
+          console.log('[ClipboardBridge] DataTransfer created');
+        } catch (error) {
+          console.warn('[ClipboardBridge] Could not create DataTransfer', error);
+        }
+        
+        if (dataTransfer) {
+          if (payload.text) {
+            try {
+              dataTransfer.setData("text/plain", payload.text);
+              console.log('[ClipboardBridge] Set text/plain:', payload.text.substring(0, 50));
+            } catch (error) {
+              console.warn('[ClipboardBridge] Failed to set text/plain', error);
+            }
+          }
+          if (payload.html) {
+            try {
+              dataTransfer.setData("text/html", payload.html);
+              console.log('[ClipboardBridge] Set text/html:', payload.html.substring(0, 50));
+            } catch (error) {
+              console.warn('[ClipboardBridge] Failed to set text/html', error);
+            }
+          }
+        }
+        
+        // Get target element
+        let target = document.activeElement || document.body;
+        console.log('[ClipboardBridge] Target element:', {
+          tagName: target.tagName,
+          type: target.type,
+          isContentEditable: target.isContentEditable,
+          id: target.id,
+          className: target.className
+        });
+        
+        // Try synthetic paste event first
+        let pasteHandled = false;
+        if (dataTransfer && target && typeof target.dispatchEvent === "function") {
+          try {
+            const pasteEvent = new ClipboardEvent("paste", {
+              clipboardData: dataTransfer,
+              bubbles: true,
+              cancelable: true,
+            });
+            pasteHandled = target.dispatchEvent(pasteEvent);
+            console.log('[ClipboardBridge] Paste event dispatched, handled:', pasteHandled);
+          } catch (error) {
+            console.warn('[ClipboardBridge] Failed to dispatch paste event', error);
+          }
+        }
+        
+        
+        console.log('[ClipboardBridge] Paste event not handled, trying fallback methods');
+        
+        // Fallback: Try execCommand with HTML first (for contenteditable)
+        if (payload.html && target.isContentEditable) {
+          console.log('[ClipboardBridge] Trying execCommand insertHTML');
+          try {
+            const inserted = document.execCommand('insertHTML', false, payload.html);
+            if (inserted) {
+              console.log('[ClipboardBridge] Successfully inserted HTML via execCommand');
+              return true;
+            }
+          } catch (error) {
+            console.warn('[ClipboardBridge] execCommand insertHTML failed', error);
+          }
+          
+          // Try Range API for HTML
+          console.log('[ClipboardBridge] Trying Range API for HTML');
+          try {
+            const selection = window.getSelection?.();
+            if (selection && selection.rangeCount > 0) {
+              const range = selection.getRangeAt(0);
+              range.deleteContents();
+              const fragment = range.createContextualFragment(payload.html);
+              range.insertNode(fragment);
+              range.collapse(false);
+              console.log('[ClipboardBridge] Successfully inserted HTML via Range API');
+              return true;
+            }
+          } catch (error) {
+            console.warn('[ClipboardBridge] Range API HTML insertion failed', error);
+          }
+        }
+        
+        // Fallback: Try execCommand with text
+        if (payload.text) {
+          console.log('[ClipboardBridge] Trying execCommand insertText');
+          try {
+            const inserted = document.execCommand('insertText', false, payload.text);
+            if (inserted) {
+              console.log('[ClipboardBridge] Successfully inserted text via execCommand');
+              return true;
+            }
+          } catch (error) {
+            console.warn('[ClipboardBridge] execCommand insertText failed', error);
+          }
+          
+          // Try Range API for text
+          if (target.isContentEditable) {
+            console.log('[ClipboardBridge] Trying Range API for text');
+            try {
+              const selection = window.getSelection?.();
+              if (selection && selection.rangeCount > 0) {
+                const range = selection.getRangeAt(0);
+                range.deleteContents();
+                range.insertNode(document.createTextNode(payload.text));
+                range.collapse(false);
+                console.log('[ClipboardBridge] Successfully inserted text via Range API');
+                return true;
+              }
+            } catch (error) {
+              console.warn('[ClipboardBridge] Range API text insertion failed', error);
+            }
+          }
+          
+          // Last resort: Direct value assignment for input/textarea
+          if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') {
+            console.log('[ClipboardBridge] Trying direct value assignment');
+            try {
+              const start = target.selectionStart ?? target.value.length ?? 0;
+              const end = target.selectionEnd ?? target.value.length ?? 0;
+              const value = target.value ?? "";
+              const text = payload.text;
+              target.value = value.slice(0, start) + text + value.slice(end);
+              const caret = start + text.length;
+              if (typeof target.setSelectionRange === 'function') {
+                target.setSelectionRange(caret, caret);
+              }
+              target.dispatchEvent(new Event('input', { bubbles: true }));
+              console.log('[ClipboardBridge] Successfully set value directly');
+              return true;
+            } catch (error) {
+              console.warn('[ClipboardBridge] Direct value assignment failed', error);
+            }
+          }
+        }
+        
+        console.warn('[ClipboardBridge] All paste methods failed');
+        return false;
+      } catch (error) {
+        console.error('[ClipboardBridge] Error applying clipboard data:', error);
+        return false;
+      }
+    };
+
+    // Set up event listeners for copy/cut
     document.addEventListener(
       "copy",
       (event) => {
@@ -160,8 +323,20 @@ export function getInitScript(config, options) {
       },
       true
     );
+    
+    console.log('[ClipboardBridge] Clipboard bridge initialized successfully');
   })();
+`;
+
+export function getInitScript(config, options) {
+  const preScript = `
+  window.__bvt_Recorder_config = ${JSON.stringify(config ?? null)};
+  window.__PW_options = ${JSON.stringify(options ?? null)};
   `;
+  const recorderScript = readFileSync(
+    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
+    "utf8"
+  );
   return preScript + recorderScript + clipboardBridgeScript;
 }
 
@@ -1539,25 +1714,55 @@ export class BVTRecorder {
 
   async applyClipboardPayload(message) {
     const payload = message?.data ?? message;
+
+    this.logger.info("[BVTRecorder] applyClipboardPayload called", {
+      hasPayload: !!payload,
+      hasText: !!payload?.text,
+      hasHtml: !!payload?.html,
+      trigger: message?.trigger,
+    });
+
     if (!payload) {
+      this.logger.warn("[BVTRecorder] No payload provided");
       return;
     }
 
     try {
       if (this.browserEmitter && typeof this.browserEmitter.applyClipboardPayload === "function") {
+        this.logger.info("[BVTRecorder] Using RemoteBrowserService to apply clipboard");
         await this.browserEmitter.applyClipboardPayload(payload);
         return;
       }
 
       const activePage = this.browserEmitter?.getSelectedPage() ?? this.page;
       if (!activePage) {
-        this.logger.warn("No active page available to apply clipboard payload");
+        this.logger.warn("[BVTRecorder] No active page available");
         return;
       }
 
-      await this.injectClipboardIntoPage(activePage, payload);
+      this.logger.info("[BVTRecorder] Applying clipboard to page", {
+        url: activePage.url(),
+        isClosed: activePage.isClosed(),
+      });
+
+      const result = await activePage.evaluate((clipboardData) => {
+        console.log("[Page] Executing clipboard application", clipboardData);
+        if (typeof window.__bvt_applyClipboardData === "function") {
+          return window.__bvt_applyClipboardData(clipboardData);
+        }
+        console.error("[Page] __bvt_applyClipboardData function not found!");
+        return false;
+      }, payload);
+
+      this.logger.info("[BVTRecorder] Clipboard application result:", result);
+
+      if (!result) {
+        this.logger.warn("[BVTRecorder] Clipboard data not applied successfully");
+      } else {
+        this.logger.info("[BVTRecorder] Clipboard data applied successfully");
+      }
     } catch (error) {
-      this.logger.error("Error applying clipboard payload to page", error);
+      this.logger.error("[BVTRecorder] Error applying clipboard payload", error);
       this.sendEvent(this.events.clipboardError, {
         message: "Failed to apply clipboard contents to the remote session",
         trigger: message?.trigger ?? "paste",
@@ -1565,6 +1770,152 @@ export class BVTRecorder {
     }
   }
 
+  hasClipboardPayload(payload) {
+    return Boolean(
+      payload && (payload.text || payload.html || (Array.isArray(payload.files) && payload.files.length > 0))
+    );
+  }
+
+  async collectClipboardFromPage(page) {
+    if (!page) {
+      this.logger.warn("[BVTRecorder] No page available to collect clipboard data");
+      return null;
+    }
+    try {
+      await page
+        .context()
+        .grantPermissions(["clipboard-read", "clipboard-write"])
+        .catch((error) => {
+          this.logger.warn("[BVTRecorder] Failed to grant clipboard permissions before read", error);
+        });
+
+      const payload = await page.evaluate(async () => {
+        const result = {};
+        if (typeof navigator === "undefined" || !navigator.clipboard) {
+          return result;
+        }
+
+        const arrayBufferToBase64 = (buffer) => {
+          let binary = "";
+          const bytes = new Uint8Array(buffer);
+          const chunkSize = 0x8000;
+          for (let index = 0; index < bytes.length; index += chunkSize) {
+            const chunk = bytes.subarray(index, index + chunkSize);
+            binary += String.fromCharCode(...chunk);
+          }
+          return btoa(binary);
+        };
+
+        const files = [];
+
+        if (typeof navigator.clipboard.read === "function") {
+          try {
+            const items = await navigator.clipboard.read();
+            for (const item of items) {
+              if (item.types.includes("text/html") && !result.html) {
+                const blob = await item.getType("text/html");
+                result.html = await blob.text();
+              }
+              if (item.types.includes("text/plain") && !result.text) {
+                const blob = await item.getType("text/plain");
+                result.text = await blob.text();
+              }
+              for (const type of item.types) {
+                if (type.startsWith("text/")) {
+                  continue;
+                }
+                try {
+                  const blob = await item.getType(type);
+                  const buffer = await blob.arrayBuffer();
+                  files.push({
+                    name: `clipboard-file-${files.length + 1}`,
+                    type,
+                    lastModified: Date.now(),
+                    data: arrayBufferToBase64(buffer),
+                  });
+                } catch (error) {
+                  console.warn("[BVTRecorder] Failed to serialize clipboard blob", { type, error });
+                }
+              }
+            }
+          } catch (error) {
+            console.warn("[BVTRecorder] navigator.clipboard.read failed", error);
+          }
+        }
+
+        if (!result.text && typeof navigator.clipboard.readText === "function") {
+          try {
+            const text = await navigator.clipboard.readText();
+            if (text) {
+              result.text = text;
+            }
+          } catch (error) {
+            console.warn("[BVTRecorder] navigator.clipboard.readText failed", error);
+          }
+        }
+
+        if (!result.text) {
+          const selection = window.getSelection?.()?.toString?.();
+          if (selection) {
+            result.text = selection;
+          }
+        }
+
+        if (files.length > 0) {
+          result.files = files;
+        }
+
+        return result;
+      });
+
+      return payload;
+    } catch (error) {
+      this.logger.error("[BVTRecorder] Error collecting clipboard payload", error);
+      return null;
+    }
+  }
+
+  async readClipboardPayload(message) {
+    try {
+      let payload = null;
+      if (this.browserEmitter && typeof this.browserEmitter.readClipboardPayload === "function") {
+        payload = await this.browserEmitter.readClipboardPayload();
+      } else {
+        const activePage = this.browserEmitter?.getSelectedPage() ?? this.page;
+        payload = await this.collectClipboardFromPage(activePage);
+      }
+
+      if (this.hasClipboardPayload(payload)) {
+        this.logger.info("[BVTRecorder] Remote clipboard payload ready", {
+          hasText: !!payload.text,
+          hasHtml: !!payload.html,
+          files: payload.files?.length ?? 0,
+        });
+        this.sendEvent(this.events.clipboardPush, {
+          data: payload,
+          trigger: message?.trigger ?? "copy",
+          origin: message?.source ?? "browserUI",
+        });
+        return payload;
+      }
+
+      this.logger.warn("[BVTRecorder] Remote clipboard payload empty or unavailable");
+      this.sendEvent(this.events.clipboardError, {
+        message: "Remote clipboard is empty",
+        trigger: message?.trigger ?? "copy",
+      });
+      return null;
+    } catch (error) {
+      this.logger.error("[BVTRecorder] Error reading clipboard payload", error);
+      this.sendEvent(this.events.clipboardError, {
+        message: "Failed to read clipboard contents from the remote session",
+        trigger: message?.trigger ?? "copy",
+        details: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   async injectClipboardIntoPage(page, payload) {
     if (!page) {
       return;
@@ -1576,6 +1927,7 @@ export class BVTRecorder {
         .grantPermissions(["clipboard-read", "clipboard-write"])
         .catch(() => {});
       await page.evaluate(async (clipboardPayload) => {
+        console.log("Injecting clipboard payload", clipboardPayload);
         const toArrayBuffer = (base64) => {
           if (!base64) {
             return null;

package/bin/client/recorderv3/services.js

@@ -220,6 +220,15 @@ export class RemoteBrowserService extends EventEmitter {
     pages = new Map();
     _selectedPageId = null;
     wsUrlBase; // Store the base URL
+    hasClipboardData(payload) {
+        return Boolean(payload && (payload.text || payload.html || (Array.isArray(payload.files) && payload.files.length > 0)));
+    }
+    getSelectedPageInfo() {
+        if (!this._selectedPageId) {
+            return null;
+        }
+        return this.pages.get(this._selectedPageId) ?? null;
+    }
     constructor({ CDP_CONNECT_URL, context }) {
         super();
         this.CDP_CONNECT_URL = CDP_CONNECT_URL;
@@ -507,182 +516,247 @@ export class RemoteBrowserService extends EventEmitter {
         }
     }
     async applyClipboardPayload(payload) {
+        this.log("📋 applyClipboardPayload called", {
+            hasText: !!payload?.text,
+            hasHtml: !!payload?.html,
+            hasFiles: !!payload?.files,
+            textLength: payload?.text?.length,
+            htmlLength: payload?.html?.length,
+            filesCount: payload?.files?.length,
+        });
         const pageInfo = this.getPageInfo(this._selectedPageId);
         if (!pageInfo) {
-            this.log("⚠️ No active page available for clipboard payload");
+            this.log("⚠️ No active page available for clipboard payload", {
+                selectedPageId: this._selectedPageId,
+                totalPages: this.pages.size,
+            });
             return;
         }
+        this.log("📄 Target page info", {
+            stableTabId: this._selectedPageId,
+            url: pageInfo.page.url(),
+            isClosed: pageInfo.page.isClosed(),
+            title: await pageInfo.page.title().catch(() => "unknown"),
+        });
         try {
+            // Grant permissions first
+            this.log("🔐 Attempting to grant clipboard permissions");
             await pageInfo.page
                 .context()
                 .grantPermissions(["clipboard-read", "clipboard-write"])
-                .catch(() => { });
-            await pageInfo.page.evaluate(async (clipboardPayload) => {
-                const toArrayBuffer = (base64) => {
-                    if (!base64) {
-                        return null;
-                    }
-                    const binary = atob(base64);
-                    const length = binary.length;
-                    const bytes = new Uint8Array(length);
-                    for (let index = 0; index < length; index += 1) {
-                        bytes[index] = binary.charCodeAt(index);
-                    }
-                    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-                };
-                const createFileFromPayload = (filePayload) => {
-                    const buffer = toArrayBuffer(filePayload?.data);
-                    if (!buffer) {
-                        return null;
-                    }
-                    const name = filePayload?.name || "clipboard-file";
-                    const type = filePayload?.type || "application/octet-stream";
-                    const lastModified = filePayload?.lastModified ?? Date.now();
-                    try {
-                        return new File([buffer], name, { type, lastModified });
-                    }
-                    catch (error) {
-                        console.warn("Clipboard bridge could not recreate File", error);
-                        return null;
-                    }
-                };
-                let dataTransfer = null;
+                .then(() => {
+                this.log("✅ Clipboard permissions granted");
+            })
+                .catch((error) => {
+                this.log("⚠️ Failed to grant clipboard permissions", { error: error.message });
+            });
+            // Apply the clipboard data using the injected function
+            this.log("🚀 Executing clipboard application script", {
+                payloadPreview: {
+                    text: payload?.text?.substring(0, 100),
+                    html: payload?.html?.substring(0, 100),
+                },
+            });
+            const result = await pageInfo.page.evaluate((clipboardData) => {
+                console.log("[RemoteBrowser->Page] Starting clipboard application");
+                console.log("[RemoteBrowser->Page] Payload:", {
+                    hasText: !!clipboardData?.text,
+                    hasHtml: !!clipboardData?.html,
+                    text: clipboardData?.text?.substring(0, 50),
+                    html: clipboardData?.html?.substring(0, 50),
+                });
+                // Check if the function exists
+                if (typeof window.__bvt_applyClipboardData !== "function") {
+                    console.error("[RemoteBrowser->Page] ❌ __bvt_applyClipboardData function not found!");
+                    console.log("[RemoteBrowser->Page] Available window properties:", Object.keys(window).filter((k) => k.includes("bvt")));
+                    return false;
+                }
+                console.log("[RemoteBrowser->Page] ✅ __bvt_applyClipboardData function found, calling it");
                 try {
-                    dataTransfer = new DataTransfer();
+                    const result = window.__bvt_applyClipboardData(clipboardData);
+                    console.log("[RemoteBrowser->Page] Function returned:", result);
+                    return result;
                 }
                 catch (error) {
-                    console.warn("Clipboard bridge could not create DataTransfer", error);
+                    console.error("[RemoteBrowser->Page] ❌ Error calling __bvt_applyClipboardData:", error);
+                    return false;
                 }
-                const callLegacyExecCommand = (command, value) => {
-                    const execCommand = document.execCommand;
-                    if (typeof execCommand === "function") {
-                        try {
-                            return execCommand.call(document, command, false, value);
-                        }
-                        catch (error) {
-                            console.warn("Clipboard bridge failed to execute legacy command", error);
-                        }
+            }, payload);
+            this.log("📊 Clipboard application result", {
+                success: result,
+                selectedPageId: this._selectedPageId,
+            });
+            if (!result) {
+                this.log("⚠️ Clipboard script returned false - data may not have been applied");
+            }
+            else {
+                this.log("✅ Clipboard payload applied successfully");
+            }
+        }
+        catch (error) {
+            this.log("❌ Error applying clipboard payload", {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+                selectedPageId: this._selectedPageId,
+                pageUrl: pageInfo.page.url(),
+            });
+            throw error;
+        }
+    }
+    async readClipboardPayload() {
+        const pageInfo = this.getSelectedPageInfo();
+        if (!pageInfo) {
+            this.log("⚠️ Cannot read clipboard - no active page", { selectedPageId: this._selectedPageId });
+            return null;
+        }
+        try {
+            await pageInfo.page
+                .context()
+                .grantPermissions(["clipboard-read", "clipboard-write"])
+                .catch((error) => {
+                this.log("⚠️ Failed to ensure clipboard permissions before read", { error });
+            });
+            const payload = await pageInfo.page.evaluate(async () => {
+                const result = {};
+                if (typeof navigator === "undefined" || !navigator.clipboard) {
+                    return result;
+                }
+                const arrayBufferToBase64 = (buffer) => {
+                    let binary = "";
+                    const bytes = new Uint8Array(buffer);
+                    const chunkSize = 0x8000;
+                    for (let index = 0; index < bytes.length; index += chunkSize) {
+                        const chunk = bytes.subarray(index, index + chunkSize);
+                        binary += String.fromCharCode(...chunk);
                     }
-                    return false;
+                    return btoa(binary);
                 };
-                if (dataTransfer) {
-                    if (clipboardPayload?.text) {
-                        try {
-                            dataTransfer.setData("text/plain", clipboardPayload.text);
-                        }
-                        catch (error) {
-                            console.warn("Clipboard bridge failed to attach text/plain", error);
-                        }
-                    }
-                    if (clipboardPayload?.html) {
-                        try {
-                            dataTransfer.setData("text/html", clipboardPayload.html);
-                        }
-                        catch (error) {
-                            console.warn("Clipboard bridge failed to attach text/html", error);
-                        }
-                    }
-                    if (Array.isArray(clipboardPayload?.files)) {
-                        for (const filePayload of clipboardPayload.files) {
-                            const file = createFileFromPayload(filePayload);
-                            if (file) {
+                const files = [];
+                if (typeof navigator.clipboard.read === "function") {
+                    try {
+                        const items = await navigator.clipboard.read();
+                        for (const item of items) {
+                            if (item.types.includes("text/html") && !result.html) {
+                                const blob = await item.getType("text/html");
+                                result.html = await blob.text();
+                            }
+                            if (item.types.includes("text/plain") && !result.text) {
+                                const blob = await item.getType("text/plain");
+                                result.text = await blob.text();
+                            }
+                            for (const type of item.types) {
+                                if (type.startsWith("text/")) {
+                                    continue;
+                                }
                                 try {
-                                    dataTransfer.items.add(file);
+                                    const blob = await item.getType(type);
+                                    const buffer = await blob.arrayBuffer();
+                                    files.push({
+                                        name: `clipboard-file-${files.length + 1}`,
+                                        type,
+                                        lastModified: Date.now(),
+                                        data: arrayBufferToBase64(buffer),
+                                    });
                                 }
                                 catch (error) {
-                                    console.warn("Clipboard bridge failed to attach file", error);
+                                    console.warn("[RemoteClipboard] Failed to serialize clipboard blob", { type, error });
                                 }
                             }
                         }
                     }
-                }
-                let target = document.activeElement;
-                if (!target || target === document.body) {
-                    target = document.body;
-                }
-                let pasteHandled = false;
-                if (dataTransfer && target && typeof target.dispatchEvent === "function") {
-                    try {
-                        const clipboardEvent = new ClipboardEvent("paste", {
-                            clipboardData: dataTransfer,
-                            bubbles: true,
-                            cancelable: true,
-                        });
-                        pasteHandled = target.dispatchEvent(clipboardEvent);
-                    }
                     catch (error) {
-                        console.warn("Clipboard bridge failed to dispatch paste event", error);
+                        console.warn("[RemoteClipboard] navigator.clipboard.read failed", error);
                     }
                 }
-                if (pasteHandled) {
-                    return;
-                }
-                if (clipboardPayload?.html) {
-                    const inserted = callLegacyExecCommand("insertHTML", clipboardPayload.html);
-                    if (inserted) {
-                        return;
-                    }
+                if (!result.text && typeof navigator.clipboard.readText === "function") {
                     try {
-                        const selection = window.getSelection?.();
-                        if (selection && selection.rangeCount > 0) {
-                            const range = selection.getRangeAt(0);
-                            range.deleteContents();
-                            const fragment = range.createContextualFragment(clipboardPayload.html);
-                            range.insertNode(fragment);
-                            range.collapse(false);
-                            return;
+                        const text = await navigator.clipboard.readText();
+                        if (text) {
+                            result.text = text;
                         }
                     }
                     catch (error) {
-                        console.warn("Clipboard bridge could not insert HTML via Range APIs", error);
+                        console.warn("[RemoteClipboard] navigator.clipboard.readText failed", error);
                     }
                 }
-                if (clipboardPayload?.text) {
-                    const inserted = callLegacyExecCommand("insertText", clipboardPayload.text);
-                    if (inserted) {
-                        return;
-                    }
-                    try {
-                        const selection = window.getSelection?.();
-                        if (selection && selection.rangeCount > 0) {
-                            const range = selection.getRangeAt(0);
-                            range.deleteContents();
-                            range.insertNode(document.createTextNode(clipboardPayload.text));
-                            range.collapse(false);
-                            return;
-                        }
-                    }
-                    catch (error) {
-                        console.warn("Clipboard bridge could not insert text via Range APIs", error);
+                if (!result.text) {
+                    const selection = window.getSelection?.()?.toString?.();
+                    if (selection) {
+                        result.text = selection;
                     }
                 }
-                if (clipboardPayload?.text && target && "value" in target) {
-                    try {
-                        const input = target;
-                        const start = input.selectionStart ?? input.value.length ?? 0;
-                        const end = input.selectionEnd ?? input.value.length ?? 0;
-                        const value = input.value ?? "";
-                        const text = clipboardPayload.text;
-                        input.value = `${value.slice(0, start)}${text}${value.slice(end)}`;
-                        const caret = start + text.length;
-                        if (typeof input.setSelectionRange === "function") {
-                            input.setSelectionRange(caret, caret);
-                        }
-                        input.dispatchEvent(new Event("input", { bubbles: true }));
-                    }
-                    catch (error) {
-                        console.warn("Clipboard bridge failed to insert text into input", error);
-                    }
+                if (files.length > 0) {
+                    result.files = files;
                 }
-            }, payload);
+                return result;
+            });
+            if (this.hasClipboardData(payload)) {
+                this.log("📋 Remote clipboard payload captured", {
+                    hasText: !!payload.text,
+                    hasHtml: !!payload.html,
+                    fileCount: payload.files?.length ?? 0,
+                });
+                return payload;
+            }
+            this.log("ℹ️ Remote clipboard read returned empty payload", {
+                selectedPageId: this._selectedPageId,
+            });
+            return null;
         }
         catch (error) {
-            this.log("❌ Error applying clipboard payload", { error });
+            this.log("❌ Error reading remote clipboard", {
+                error: error instanceof Error ? error.message : String(error),
+            });
             throw error;
         }
     }
+    // Add a helper method to verify clipboard script is loaded
+    async verifyClipboardScript(stableTabId) {
+        const pageInfo = this.pages.get(stableTabId);
+        if (!pageInfo) {
+            this.log("⚠️ Cannot verify clipboard script - page not found", { stableTabId });
+            return false;
+        }
+        try {
+            const isLoaded = await pageInfo.page.evaluate(() => {
+                return (typeof window.__bvt_applyClipboardData === "function" && typeof window.__bvt_reportClipboard === "function");
+            });
+            this.log("🔍 Clipboard script verification", {
+                stableTabId,
+                isLoaded,
+                url: pageInfo.page.url(),
+            });
+            return isLoaded;
+        }
+        catch (error) {
+            this.log("❌ Error verifying clipboard script", {
+                stableTabId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    // Call this after navigation to ensure script is loaded
+    async ensureClipboardScriptLoaded(page) {
+        try {
+            const isLoaded = await page.evaluate(() => {
+                return typeof window.__bvt_applyClipboardData === "function";
+            });
+            if (!isLoaded) {
+                this.log("⚠️ Clipboard script not loaded, attempting to reload");
+                // The script should be in initScripts, so it will load on next navigation
+                // or you could manually inject it here
+            }
+            else {
+                this.log("✅ Clipboard script confirmed loaded");
+            }
+        }
+        catch (error) {
+            this.log("❌ Error checking clipboard script", { error });
+        }
+    }
     getSelectedPage() {
-        const pageInfo = this._selectedPageId ? this.pages.get(this._selectedPageId) : null;
+        const pageInfo = this.getSelectedPageInfo();
         this.log("🔍 Getting selected page", {
             selectedPageId: this._selectedPageId,
             found: !!pageInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1624-dev",
+  "version": "1.0.1625-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",