@dev-blinq/cucumber_client 1.0.1612-dev → 1.0.1614-dev

package/bin/client/recorderv3/bvt_init.js

@@ -311,6 +311,26 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
       console.log("Received browserUI.selectTab", input);
       await recorder.selectTab(input);
     },
+    "browserUI.navigateTab": async (input) => {
+      console.log("Received browserUI.navigateTab", input);
+      await recorder.navigateTab(input);
+    },
+    "browserUI.reloadTab": async (input) => {
+      console.log("Received browserUI.reloadTab", input);
+      await recorder.reloadTab(input);
+    },
+    "browserUI.goBack": async (input) => {
+      console.log("Received browserUI.goBack", input);
+      await recorder.goBack(input);
+    },
+    "browserUI.goForward": async (input) => {
+      console.log("Received browserUI.goForward", input);
+      await recorder.goForward(input);
+    },
+    "browserUI.clipboardWrite": async (input) => {
+      console.log("Received browserUI.clipboardWrite");
+      await recorder.applyClipboardPayload(input);
+    },
     "recorderWindow.cleanup": async (input) => {
       return recorder.cleanup(input);
     },

package/bin/client/recorderv3/bvt_recorder.js

@@ -30,7 +30,139 @@ export function getInitScript(config, options) {
     path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
     "utf8"
   );
-  return preScript + recorderScript;
+  const clipboardBridgeScript = `
+  ;(() => {
+    if (window.__bvtRecorderClipboardBridgeInitialized) {
+      return;
+    }
+    window.__bvtRecorderClipboardBridgeInitialized = true;
+
+    const emitPayload = (payload, attempt = 0) => {
+      const reporter = window.__bvt_reportClipboard;
+      if (typeof reporter === "function") {
+        try {
+          reporter(payload);
+        } catch (error) {
+          console.warn("Clipboard bridge failed to report payload", error);
+        }
+        return;
+      }
+      if (attempt < 5) {
+        setTimeout(() => emitPayload(payload, attempt + 1), 50 * (attempt + 1));
+      }
+    };
+
+    const fileToBase64 = (file) => {
+      return new Promise((resolve) => {
+        try {
+          const reader = new FileReader();
+          reader.onload = () => {
+            const { result } = reader;
+            if (typeof result === "string") {
+              const index = result.indexOf("base64,");
+              resolve(index !== -1 ? result.substring(index + 7) : result);
+              return;
+            }
+            if (result instanceof ArrayBuffer) {
+              const bytes = new Uint8Array(result);
+              let binary = "";
+              const chunk = 0x8000;
+              for (let i = 0; i < bytes.length; i += chunk) {
+                binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+              }
+              resolve(btoa(binary));
+              return;
+            }
+            resolve(null);
+          };
+          reader.onerror = () => resolve(null);
+          reader.readAsDataURL(file);
+        } catch (error) {
+          console.warn("Clipboard bridge failed to serialize file", error);
+          resolve(null);
+        }
+      });
+    };
+
+    const handleClipboardEvent = async (event) => {
+      try {
+        const payload = { trigger: event.type };
+        const clipboardData = event.clipboardData;
+
+        if (clipboardData) {
+          try {
+            const text = clipboardData.getData("text/plain");
+            if (text) {
+              payload.text = text;
+            }
+          } catch (error) {
+            console.warn("Clipboard bridge could not read text/plain", error);
+          }
+
+          try {
+            const html = clipboardData.getData("text/html");
+            if (html) {
+              payload.html = html;
+            }
+          } catch (error) {
+            console.warn("Clipboard bridge could not read text/html", error);
+          }
+
+          const files = clipboardData.files;
+          if (files && files.length > 0) {
+            const serialized = [];
+            for (const file of files) {
+              const data = await fileToBase64(file);
+              if (data) {
+                serialized.push({
+                  name: file.name,
+                  type: file.type,
+                  lastModified: file.lastModified,
+                  data,
+                });
+              }
+            }
+            if (serialized.length > 0) {
+              payload.files = serialized;
+            }
+          }
+        }
+
+        if (!payload.text) {
+          try {
+            const selection = window.getSelection?.();
+            const selectionText = selection?.toString?.();
+            if (selectionText) {
+              payload.text = selectionText;
+            }
+          } catch {
+            // Ignore selection access errors.
+          }
+        }
+
+        emitPayload(payload);
+      } catch (error) {
+        console.warn("Clipboard bridge could not process event", error);
+      }
+    };
+
+    document.addEventListener(
+      "copy",
+      (event) => {
+        void handleClipboardEvent(event);
+      },
+      true
+    );
+    document.addEventListener(
+      "cut",
+      (event) => {
+        void handleClipboardEvent(event);
+      },
+      true
+    );
+  })();
+  `;
+  return preScript + recorderScript + process.env.REMOTE_RECORDER === "true" ? clipboardBridgeScript : `;`;
 }
 
 async function evaluate(frame, script) {
@@ -200,7 +332,7 @@ export class BVTRecorder {
     this.workspaceService = new PublishService(this.TOKEN);
     this.pageSet = new Set();
     this.lastKnownUrlPath = "";
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
     this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
@@ -228,6 +360,8 @@ export class BVTRecorder {
     updateCommand: "BVTRecorder.updateCommand",
     browserStateSync: "BrowserService.stateSync",
     browserStateError: "BrowserService.stateError",
+    clipboardPush: "BrowserService.clipboardPush",
+    clipboardError: "BrowserService.clipboardError",
   };
   bindings = {
     __bvt_recordCommand: async ({ frame, page, context }, event) => {
@@ -257,6 +391,25 @@ export class BVTRecorder {
     __bvt_getObject: (_src, obj) => {
       this.processObject(obj);
     },
+    __bvt_reportClipboard: async ({ page }, payload) => {
+      try {
+        if (!payload) {
+          return;
+        }
+        const activePage = this.browserEmitter?.getSelectedPage() ?? this.page;
+        if (activePage && activePage !== page) {
+          return;
+        }
+        const pageUrl = typeof page?.url === "function" ? page.url() : null;
+        this.sendEvent(this.events.clipboardPush, {
+          data: payload,
+          trigger: payload?.trigger ?? "copy",
+          pageUrl,
+        });
+      } catch (error) {
+        this.logger.error("Error forwarding clipboard payload from page", error);
+      }
+    },
   };
 
   getSnapshot = async (attr) => {
@@ -322,7 +475,7 @@ export class BVTRecorder {
     }
 
     // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -824,7 +977,7 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => { });
+    await this.watcher.close().then(() => {});
     this.watcher = null;
     this.previousIndex = null;
     this.previousHistoryLength = null;
@@ -1381,6 +1534,207 @@ export class BVTRecorder {
     }
   }
 
+  async applyClipboardPayload(message) {
+    const payload = message?.data ?? message;
+    if (!payload) {
+      return;
+    }
+
+    try {
+      if (this.browserEmitter && typeof this.browserEmitter.applyClipboardPayload === "function") {
+        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");
+        return;
+      }
+
+      await this.injectClipboardIntoPage(activePage, payload);
+    } catch (error) {
+      this.logger.error("Error applying clipboard payload to page", error);
+      this.sendEvent(this.events.clipboardError, {
+        message: "Failed to apply clipboard contents to the remote session",
+        trigger: message?.trigger ?? "paste",
+      });
+    }
+  }
+
+  async injectClipboardIntoPage(page, payload) {
+    if (!page) {
+      return;
+    }
+
+    try {
+      await page
+        .context()
+        .grantPermissions(["clipboard-read", "clipboard-write"])
+        .catch(() => {});
+      await page.evaluate(async (clipboardPayload) => {
+        const toArrayBuffer = (base64) => {
+          if (!base64) {
+            return null;
+          }
+          const binaryString = atob(base64);
+          const len = binaryString.length;
+          const bytes = new Uint8Array(len);
+          for (let i = 0; i < len; i += 1) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          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 object", error);
+            return null;
+          }
+        };
+
+        let dataTransfer = null;
+        try {
+          dataTransfer = new DataTransfer();
+        } catch (error) {
+          console.warn("Clipboard bridge could not create DataTransfer", error);
+        }
+
+        if (dataTransfer) {
+          if (clipboardPayload?.text) {
+            try {
+              dataTransfer.setData("text/plain", clipboardPayload.text);
+            } catch (error) {
+              console.warn("Clipboard bridge failed to set text/plain", error);
+            }
+          }
+          if (clipboardPayload?.html) {
+            try {
+              dataTransfer.setData("text/html", clipboardPayload.html);
+            } catch (error) {
+              console.warn("Clipboard bridge failed to set text/html", error);
+            }
+          }
+          if (Array.isArray(clipboardPayload?.files)) {
+            for (const filePayload of clipboardPayload.files) {
+              const file = createFileFromPayload(filePayload);
+              if (file) {
+                try {
+                  dataTransfer.items.add(file);
+                } catch (error) {
+                  console.warn("Clipboard bridge failed to append file", error);
+                }
+              }
+            }
+          }
+        }
+
+        let target = document.activeElement || document.body;
+        if (!target) {
+          target = document.body || null;
+        }
+
+        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 synthetic paste event", error);
+          }
+        }
+
+        if (pasteHandled) {
+          return;
+        }
+
+        const callLegacyExecCommand = (command, value) => {
+          const execCommand = document && 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);
+            }
+          }
+          return false;
+        };
+
+        if (clipboardPayload?.html) {
+          const inserted = callLegacyExecCommand("insertHTML", clipboardPayload.html);
+          if (inserted) {
+            return;
+          }
+          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;
+            }
+          } catch (error) {
+            console.warn("Clipboard bridge could not insert HTML via Range APIs", 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 (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 mutate input element", error);
+          }
+        }
+      }, payload);
+    } catch (error) {
+      throw error;
+    }
+  }
+
   async createTab(url) {
     try {
       await this.browserEmitter?.createTab(url);
@@ -1416,4 +1770,56 @@ export class BVTRecorder {
       });
     }
   }
+
+  async navigateTab({ pageId, url }) {
+    try {
+      if (!pageId || !url) {
+        this.logger.error("navigateTab called without pageId or url", { pageId, url });
+        return;
+      }
+      await this.browserEmitter?.navigateTab(pageId, url);
+    } catch (error) {
+      this.logger.error("Error navigating tab:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error navigating tab",
+        code: "NAVIGATE_TAB_ERROR",
+      });
+    }
+  }
+
+  async reloadTab(pageId) {
+    try {
+      await this.browserEmitter?.reloadTab(pageId);
+    } catch (error) {
+      this.logger.error("Error reloading tab:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error reloading tab",
+        code: "RELOAD_TAB_ERROR",
+      });
+    }
+  }
+
+  async goBack(pageId) {
+    try {
+      await this.browserEmitter?.goBack(pageId);
+    } catch (error) {
+      this.logger.error("Error navigating back:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error navigating back",
+        code: "GO_BACK_ERROR",
+      });
+    }
+  }
+
+  async goForward(pageId) {
+    try {
+      await this.browserEmitter?.goForward(pageId);
+    } catch (error) {
+      this.logger.error("Error navigating forward:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error navigating forward",
+        code: "GO_FORWARD_ERROR",
+      });
+    }
+  }
 }

package/bin/client/recorderv3/services.js

@@ -226,6 +226,9 @@ export class RemoteBrowserService extends EventEmitter {
         this.context = context;
         this.wsUrlBase = this.CDP_CONNECT_URL.replace(/^http/, "ws") + "/devtools/page/";
         this.log("🚀 RemoteBrowserService initialized", { CDP_CONNECT_URL });
+        this.context.grantPermissions(["clipboard-read", "clipboard-write"]).catch((error) => {
+            this.log("⚠️ Failed to pre-grant clipboard permissions", { error });
+        });
         this.initializeListeners();
     }
     log(message, data) {
@@ -259,6 +262,21 @@ export class RemoteBrowserService extends EventEmitter {
     }
     async initializeListeners() {
         this.log("📡 Initializing listeners");
+        // Initialize with existing pages
+        const existingPages = this.context.pages();
+        this.log("📄 Found existing pages", { count: existingPages.length });
+        for (const page of existingPages) {
+            const stableTabId = uuidv4();
+            const cdpTargetId = await this.getCdpTargetId(page);
+            this.pages.set(stableTabId, { page, cdpTargetId });
+            this.log("✅ Existing page added to map", { stableTabId, cdpTargetId, url: page.url() });
+            this.attachPageLifecycleListeners(page, stableTabId);
+            this.log("🔍 Attached lifecycle listeners to existing page", { stableTabId });
+        }
+        if (this.pages.size > 0 && !this._selectedPageId) {
+            this._selectedPageId = Array.from(this.pages.keys())[0];
+        }
+        await this.syncState();
         this.context.on("page", async (page) => {
             const stableTabId = uuidv4();
             this.log("🆕 New page event triggered", { stableTabId, url: page.url() });
@@ -276,33 +294,22 @@ export class RemoteBrowserService extends EventEmitter {
                 this._selectedPageId = stableTabId;
                 this.log("🎯 Initial selected page set", { selectedPageId: this._selectedPageId });
             }
+            this.attachPageLifecycleListeners(page, stableTabId);
+            await this.syncState();
+        });
+    }
+    attachPageLifecycleListeners(page, stableTabId) {
+        page.on("load", () => this.syncState());
+        page.on("framenavigated", () => this.syncState());
+        page.on("close", async () => {
+            this.log("🗑️ Page close event", { stableTabId });
+            this.pages.delete(stableTabId);
+            if (this._selectedPageId === stableTabId) {
+                this._selectedPageId = this.pages.size > 0 ? Array.from(this.pages.keys())[0] : null;
+                this.log("🔄 Selected page changed after close", { newSelectedId: this._selectedPageId });
+            }
             await this.syncState();
-            // Add listeners
-            page.on("load", () => this.syncState());
-            page.on("framenavigated", () => this.syncState());
-            page.on("close", async () => {
-                this.log("🗑️ Page close event", { stableTabId });
-                this.pages.delete(stableTabId);
-                if (this._selectedPageId === stableTabId) {
-                    this._selectedPageId = this.pages.size > 0 ? Array.from(this.pages.keys())[0] : null;
-                    this.log("🔄 Selected page changed after close", { newSelectedId: this._selectedPageId });
-                }
-                await this.syncState();
-            });
         });
-        // Initialize with existing pages
-        const existingPages = this.context.pages();
-        this.log("📄 Found existing pages", { count: existingPages.length });
-        for (const page of existingPages) {
-            const stableTabId = uuidv4();
-            const cdpTargetId = await this.getCdpTargetId(page);
-            this.pages.set(stableTabId, { page, cdpTargetId });
-            this.log("✅ Existing page added to map", { stableTabId, cdpTargetId, url: page.url() });
-        }
-        if (this.pages.size > 0 && !this._selectedPageId) {
-            this._selectedPageId = Array.from(this.pages.keys())[0];
-        }
-        await this.syncState();
     }
     async syncState() {
         try {
@@ -337,12 +344,14 @@ export class RemoteBrowserService extends EventEmitter {
                 if (!wsDebuggerUrl) {
                     this.log("⚠️ Could not get CDP ID, wsDebuggerUrl will be empty", { stableTabId });
                 }
+                const title = await pageInfo.page.title();
                 pagesData.push({
                     id: stableTabId,
-                    title: await pageInfo.page.title(),
+                    title,
                     url: pageInfo.page.url(),
                     wsDebuggerUrl: wsDebuggerUrl, // Use the constructed URL
                 });
+                this.log(`🟥Page data: ${JSON.stringify(pagesData, null, 2)}`);
             }
             catch (error) {
                 this.log("❌ Error getting page data", { stableTabId, error });
@@ -418,6 +427,260 @@ export class RemoteBrowserService extends EventEmitter {
             this.log("❌ Error selecting tab", { error });
         }
     }
+    getPageInfo(stableTabId) {
+        if (!stableTabId) {
+            this.log("⚠️ Operation requested without a selected tab");
+            return null;
+        }
+        const pageInfo = this.pages.get(stableTabId);
+        if (!pageInfo) {
+            this.log("⚠️ Page not found for operation", { stableTabId });
+            return null;
+        }
+        return pageInfo;
+    }
+    async navigateTab(stableTabId, url) {
+        const pageInfo = this.getPageInfo(stableTabId);
+        if (!pageInfo) {
+            return;
+        }
+        try {
+            this.log("🌐 Navigating tab", { stableTabId, url });
+            await pageInfo.page.goto(url, { waitUntil: "domcontentloaded" });
+            this._selectedPageId = stableTabId;
+            await this.syncState();
+        }
+        catch (error) {
+            this.log("❌ Error navigating tab", { stableTabId, url, error });
+            throw error;
+        }
+    }
+    async reloadTab(stableTabId) {
+        const pageInfo = this.getPageInfo(stableTabId);
+        if (!pageInfo) {
+            return;
+        }
+        try {
+            this.log("🔄 Reloading tab", { stableTabId, url: pageInfo.page.url() });
+            await pageInfo.page.reload({ waitUntil: "domcontentloaded" });
+            await this.syncState();
+        }
+        catch (error) {
+            this.log("❌ Error reloading tab", { stableTabId, error });
+            throw error;
+        }
+    }
+    async goBack(stableTabId) {
+        const pageInfo = this.getPageInfo(stableTabId);
+        if (!pageInfo) {
+            return;
+        }
+        try {
+            this.log("⬅️ Navigating back", { stableTabId });
+            const response = await pageInfo.page.goBack({ waitUntil: "domcontentloaded" });
+            if (!response) {
+                this.log("ℹ️ No history entry to go back to", { stableTabId });
+            }
+            await this.syncState();
+        }
+        catch (error) {
+            this.log("❌ Error navigating back", { stableTabId, error });
+            throw error;
+        }
+    }
+    async goForward(stableTabId) {
+        const pageInfo = this.getPageInfo(stableTabId);
+        if (!pageInfo) {
+            return;
+        }
+        try {
+            this.log("➡️ Navigating forward", { stableTabId });
+            const response = await pageInfo.page.goForward({ waitUntil: "domcontentloaded" });
+            if (!response) {
+                this.log("ℹ️ No history entry to go forward to", { stableTabId });
+            }
+            await this.syncState();
+        }
+        catch (error) {
+            this.log("❌ Error navigating forward", { stableTabId, error });
+            throw error;
+        }
+    }
+    async applyClipboardPayload(payload) {
+        const pageInfo = this.getPageInfo(this._selectedPageId);
+        if (!pageInfo) {
+            this.log("⚠️ No active page available for clipboard payload");
+            return;
+        }
+        try {
+            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;
+                try {
+                    dataTransfer = new DataTransfer();
+                }
+                catch (error) {
+                    console.warn("Clipboard bridge could not create DataTransfer", error);
+                }
+                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);
+                        }
+                    }
+                    return false;
+                };
+                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) {
+                                try {
+                                    dataTransfer.items.add(file);
+                                }
+                                catch (error) {
+                                    console.warn("Clipboard bridge failed to attach file", 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);
+                    }
+                }
+                if (pasteHandled) {
+                    return;
+                }
+                if (clipboardPayload?.html) {
+                    const inserted = callLegacyExecCommand("insertHTML", clipboardPayload.html);
+                    if (inserted) {
+                        return;
+                    }
+                    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;
+                        }
+                    }
+                    catch (error) {
+                        console.warn("Clipboard bridge could not insert HTML via Range APIs", 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 (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);
+                    }
+                }
+            }, payload);
+        }
+        catch (error) {
+            this.log("❌ Error applying clipboard payload", { error });
+            throw error;
+        }
+    }
     getSelectedPage() {
         const pageInfo = this._selectedPageId ? this.pages.get(this._selectedPageId) : null;
         this.log("🔍 Getting selected page", {

package/package.json

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