@dev-blinq/cucumber_client 1.0.1383-dev → 1.0.1383-stage

package/bin/client/recorderv3/services.js

@@ -2,162 +2,702 @@ import { readdirSync, readFileSync } from "fs";
 import { getRunsServiceBaseURL } from "../utils/index.js";
 import { axiosClient } from "../utils/axiosClient.js";
 import path from "path";
-
+import { EventEmitter } from "events";
+import { v4 as uuidv4 } from "uuid"; // Import uuid
 export class NamesService {
-  constructor({ screenshotMap, TOKEN, projectDir, logger }) {
-    this.screenshotMap = screenshotMap;
-    this.TOKEN = TOKEN;
-    this.projectDir = projectDir;
-    this.logger = logger;
-  }
-  async generateStepName({ commands, stepsNames, parameters, map }) {
-    let screenshot = this.screenshotMap.get(commands[commands.length - 1].inputID);
-    if (!screenshot && commands.length > 1) {
-      screenshot = this.screenshotMap.get(commands[commands.length - 2].inputID);
-    }
-    this.logger.info(
-      "data: " +
-        JSON.stringify(
-          {
-            commands,
-            stepsNames,
-            parameters,
-            map,
-          },
-          null,
-          2
-        )
-    );
-    // get screenshot for the last command
-    const url = `${getRunsServiceBaseURL()}/generate-step-information/generate`;
-    const TIMEOUT = 120; // 2 minutes
-    const { data } = await axiosClient({
-      url,
-      method: "POST",
-      data: {
-        commands,
-        stepsNames,
-        parameters,
-        screenshot,
-        map,
-      },
-      headers: {
-        Authorization: `Bearer ${this.TOKEN}`,
-        "X-Source": "recorder",
-      },
-    });
-    const actionUrl = `${getRunsServiceBaseURL()}/action/get-action?id=${data.id}`;
-    let result = { status: 500 };
-    for (let i = 0; i < TIMEOUT; i++) {
-      try {
-        const action = await axiosClient({
-          url: actionUrl,
-          method: "GET",
-          headers: {
-            Authorization: `Bearer ${this.TOKEN}`,
-            "X-Source": "recorder",
-          },
+    screenshotMap;
+    TOKEN;
+    projectDir;
+    logger;
+    constructor({ screenshotMap, TOKEN, projectDir, logger }) {
+        this.screenshotMap = screenshotMap;
+        this.TOKEN = TOKEN;
+        this.projectDir = projectDir;
+        this.logger = logger;
+    }
+    //@ts-expect-error
+    async generateStepName({ commands, stepsNames, parameters, map }) {
+        let screenshot = this.screenshotMap.get(commands[commands.length - 1].inputID);
+        if (!screenshot && commands.length > 1) {
+            screenshot = this.screenshotMap.get(commands[commands.length - 2].inputID);
+        }
+        const url = `${getRunsServiceBaseURL()}/generate-step-information/generate`;
+        const TIMEOUT = 120; // 2 minutes
+        const { data } = await axiosClient({
+            url,
+            method: "POST",
+            data: {
+                commands,
+                stepsNames,
+                parameters,
+                //screenshot,
+                map,
+            },
+            headers: {
+                Authorization: `Bearer ${this.TOKEN}`,
+                "X-Source": "recorder",
+            },
+        });
+        const actionUrl = `${getRunsServiceBaseURL()}/action/get-action?id=${data.id}`;
+        let result = { status: 500 };
+        for (let i = 0; i < TIMEOUT; i++) {
+            try {
+                const action = await axiosClient({
+                    url: actionUrl,
+                    method: "GET",
+                    headers: {
+                        Authorization: `Bearer ${this.TOKEN}`,
+                        "X-Source": "recorder",
+                    },
+                });
+                if (action.data.status) {
+                    result = action;
+                    break;
+                }
+            }
+            catch (error) {
+                if (i === TIMEOUT - 1) {
+                    this.logger.error("Timeout while generating step details: ", error instanceof Error ? error : { message: JSON.stringify(error) });
+                    console.error("Timeout while generating step details: ", error instanceof Error ? error.message : error);
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        if (result.status !== 200) {
+            return { success: false, message: "Error while generating step details" };
+        }
+        return result.data;
+    }
+    async generateScenarioAndFeatureNames(scenarioAsText) {
+        if (!this.projectDir) {
+            throw new Error("Project directory not found");
+        }
+        // read all files with .feature extension into an object {files:[{name: "", content: ""}]}
+        const featureFiles = readdirSync(path.join(this.projectDir, "features"));
+        const featureFilesContent = featureFiles
+            .filter((file) => file.endsWith(".feature"))
+            .map((file) => {
+            return {
+                name: file,
+                content: readFileSync(path.join(this.projectDir, "features", file), "utf8"),
+            };
         });
-
-        if (action.data.status) {
-          result = action;
-          break;
-        }
-      } catch (error) {
-        if (i === TIMEOUT - 1) {
-          console.error("Timeout while generating step details: ", error);
-        }
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-
-    if (result.status !== 200) {
-      return { success: false, message: "Error while generating step details" };
-    }
-    return result.data;
-  }
-  async generateScenarioAndFeatureNames(scenarioAsText) {
-    if (!this.projectDir) {
-      throw new Error("Project directory not found");
-    }
-    // read all files with .feature extension into an object {files:[{name: "", content: ""}]}
-    const featureFiles = readdirSync(path.join(this.projectDir, "features"));
-    const featureFilesContent = featureFiles
-      .filter((file) => file.endsWith(".feature"))
-      .map((file) => {
-        return {
-          name: file,
-          content: readFileSync(path.join(this.projectDir, "features", file), "utf8"),
+        const genObject = {
+            files: featureFilesContent,
+            scenario: scenarioAsText,
         };
-      });
-    const genObject = {
-      files: featureFilesContent,
-      scenario: scenarioAsText,
-    };
-
-    this.logger.info("data: " + JSON.stringify(genObject, null, 2));
-    // get screenshot for the last command
-    const url = `${getRunsServiceBaseURL()}/generate-step-information/generate_scenario_feature`;
-    const TIMEOUT = 120; // 2 minutes
-    const { data } = await axiosClient({
-      url,
-      method: "POST",
-      data: {
-        ...genObject,
-      },
-      headers: {
-        Authorization: `Bearer ${this.TOKEN}`,
-        "X-Source": "recorder",
-      },
-    });
-    const actionUrl = `${getRunsServiceBaseURL()}/action/get-action?id=${data.id}`;
-    let result = { status: 500 };
-    for (let i = 0; i < TIMEOUT; i++) {
-      try {
-        const action = await axiosClient({
-          url: actionUrl,
-          method: "GET",
-          headers: {
-            Authorization: `Bearer ${this.TOKEN}`,
-            "X-Source": "recorder",
-          },
+        // get screenshot for the last command
+        const url = `${getRunsServiceBaseURL()}/generate-step-information/generate_scenario_feature`;
+        const TIMEOUT = 120; // 2 minutes
+        const { data } = await axiosClient({
+            url,
+            method: "POST",
+            data: {
+                ...genObject,
+            },
+            headers: {
+                Authorization: `Bearer ${this.TOKEN}`,
+                "X-Source": "recorder",
+            },
+        });
+        const actionUrl = `${getRunsServiceBaseURL()}/action/get-action?id=${data.id}`;
+        let result = { status: 500 };
+        for (let i = 0; i < TIMEOUT; i++) {
+            try {
+                const action = await axiosClient({
+                    url: actionUrl,
+                    method: "GET",
+                    headers: {
+                        Authorization: `Bearer ${this.TOKEN}`,
+                        "X-Source": "recorder",
+                    },
+                });
+                if (action.data.status) {
+                    result = action;
+                    break;
+                }
+            }
+            catch (error) {
+                if (i === TIMEOUT - 1) {
+                    console.error("Timeout while generating step details: ", error);
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        if (result.status !== 200) {
+            return { success: false, message: "Error while generating step details" };
+        }
+        return result.data;
+    }
+    //@ts-expect-error
+    async generateCommandName({ command }) {
+        const url = `${getRunsServiceBaseURL()}/generate-step-information/generate-element-name`;
+        const screenshot = this.screenshotMap.get(command.inputID);
+        const result = await axiosClient({
+            url,
+            method: "POST",
+            data: { ...command, screenshot },
+            headers: {
+                Authorization: `Bearer ${this.TOKEN}`,
+                "X-Source": "recorder",
+            },
+        });
+        if (result.status !== 200) {
+            return { success: false, message: "Error while generating command details" };
+        }
+        return result.data;
+    }
+}
+export class PublishService {
+    TOKEN;
+    constructor(TOKEN) {
+        this.TOKEN = TOKEN;
+    }
+    async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env }) {
+        const runsURL = getRunsServiceBaseURL();
+        const workspaceURL = runsURL.replace("/runs", "/workspace");
+        const url = `${workspaceURL}/publish-recording`;
+        const result = await axiosClient({
+            url,
+            method: "POST",
+            data: {
+                scenario,
+                featureName,
+                override,
+                env,
+            },
+            params: {
+                branch,
+            },
+            headers: {
+                Authorization: `Bearer ${this.TOKEN}`,
+                "X-Source": "recorder",
+            },
+        });
+        if (result.status !== 200) {
+            return { success: false, message: "Error while saving scenario" };
+        }
+        try {
+            this.updateProjectMetadata({
+                featureName,
+                scenarioName: scenario.name,
+                projectId,
+                branch,
+                isEditing: override,
+            });
+        }
+        catch (error) { }
+        return { success: true, data: result.data };
+    }
+    async updateProjectMetadata({ featureName, scenarioName, projectId, branch, isEditing }) {
+        try {
+            await axiosClient({
+                method: "POST",
+                url: `${getRunsServiceBaseURL()}/project/updateProjectMetadata`,
+                data: {
+                    featureName,
+                    scenarioName,
+                    eventType: isEditing ? "editScenario" : "createScenario",
+                    projectId,
+                    branch: branch,
+                },
+                headers: {
+                    Authorization: `Bearer ${this.TOKEN}`,
+                    "X-Source": "recorder",
+                },
+            });
+        }
+        catch (error) {
+            // logger.error("Failed to update project metadata: " + error.message);
+            // @ts-ignore
+            console.error("run_recorder", `Failed to update project metadata: ${error.message ?? error}`);
+        }
+    }
+}
+export class RemoteBrowserService extends EventEmitter {
+    CDP_CONNECT_URL;
+    context;
+    pages = new Map();
+    _selectedPageId = null;
+    wsUrlBase; // Store the base URL
+    constructor({ CDP_CONNECT_URL, context }) {
+        super();
+        this.CDP_CONNECT_URL = CDP_CONNECT_URL;
+        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) {
+        const timestamp = new Date().toISOString();
+        console.log(`[${timestamp}] [RemoteBrowserService] ${message}`, data ? JSON.stringify(data, null, 2) : "");
+    }
+    /**
+     * Gets the CDP Target ID for a page *directly* from the page.
+     * This is the only reliable method during restarts.
+     */
+    async getCdpTargetId(page) {
+        try {
+            if (page.isClosed()) {
+                this.log("⚠️ Attempted to get CDP ID from a closed page");
+                return null;
+            }
+            const cdpSession = await page.context().newCDPSession(page);
+            const { targetInfo } = await cdpSession.send("Target.getTargetInfo");
+            this.log("🔍 Retrieved TargetInfo via CDP session", targetInfo);
+            await cdpSession.detach();
+            if (targetInfo && targetInfo.targetId) {
+                this.log("✅ Found CDP ID by session", { id: targetInfo.targetId, url: page.url() });
+                return targetInfo.targetId;
+            }
+            throw new Error("Target.getTargetInfo did not return a targetId");
+        }
+        catch (error) {
+            this.log("❌ Error getting CDP ID by session", { url: page.url(), error });
+            return null;
+        }
+    }
+    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() });
+            // We get the ID immediately, but it might be null if the page is too new
+            const cdpTargetId = await this.getCdpTargetId(page);
+            this.pages.set(stableTabId, { page, cdpTargetId });
+            if (cdpTargetId) {
+                this.log("✅ Page mapped to CDP ID", { stableTabId, cdpTargetId });
+            }
+            else {
+                this.log("⚠️ Could not find CDP ID for new page yet", { stableTabId });
+            }
+            if (!this._selectedPageId) {
+                // Select the first page that opens
+                this._selectedPageId = stableTabId;
+                this.log("🎯 Initial selected page set", { selectedPageId: this._selectedPageId });
+            }
+            this.attachPageLifecycleListeners(page, stableTabId);
+            await this.syncState();
         });
-
-        if (action.data.status) {
-          result = action;
-          break;
-        }
-      } catch (error) {
-        if (i === TIMEOUT - 1) {
-          console.error("Timeout while generating step details: ", error);
-        }
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-
-    if (result.status !== 200) {
-      return { success: false, message: "Error while generating step details" };
-    }
-    return result.data;
-  }
-
-  async generateCommandName({ command }) {
-    const url = `${getRunsServiceBaseURL()}/generate-step-information/generate-element-name`;
-    const screenshot = this.screenshotMap.get(command.inputID);
-    const result = await axiosClient({
-      url,
-      method: "POST",
-      data: { ...command, screenshot },
-      headers: {
-        Authorization: `Bearer ${this.TOKEN}`,
-        "X-Source": "recorder",
-      },
-    });
-    if (result.status !== 200) {
-      return { success: false, message: "Error while generating command details" };
-    }
-    return result.data;
-  }
+    }
+    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();
+        });
+    }
+    async syncState() {
+        try {
+            this.log("🔄 Starting state sync");
+            const state = await this.getState();
+            this.log("✅ State sync complete", { pagesCount: state.pages.length, selectedPageId: state.selectedPageId });
+            this.emit("BrowserService.stateSync", state);
+        }
+        catch (error) {
+            this.log("❌ Error syncing state", { error });
+        }
+    }
+    async getState() {
+        this.log("📊 Getting current state");
+        const pagesData = [];
+        const pagesToDelete = []; // To clean up closed pages
+        for (const [stableTabId, pageInfo] of this.pages.entries()) {
+            try {
+                if (pageInfo.page.isClosed()) {
+                    this.log("🧹 Found closed page during getState, marking for deletion", { stableTabId });
+                    pagesToDelete.push(stableTabId);
+                    continue;
+                }
+                // Get the one, true, live CDP ID
+                const currentCdpId = await this.getCdpTargetId(pageInfo.page);
+                if (currentCdpId && pageInfo.cdpTargetId !== currentCdpId) {
+                    this.log("🔄 CDP ID changed", { stableTabId, old: pageInfo.cdpTargetId, new: currentCdpId });
+                    pageInfo.cdpTargetId = currentCdpId; // Update our internal reference
+                }
+                // Manually construct the WebSocket URL
+                const wsDebuggerUrl = currentCdpId ? `${this.wsUrlBase}${currentCdpId}` : "";
+                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,
+                    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 });
+                pagesToDelete.push(stableTabId); // Mark for deletion
+            }
+        }
+        pagesToDelete.forEach((id) => this.pages.delete(id));
+        if (this._selectedPageId && !this.pages.has(this._selectedPageId)) {
+            this._selectedPageId = pagesData.length > 0 ? pagesData[0].id : null;
+            this.log("🔄 Corrected selectedPageId", { new: this._selectedPageId });
+        }
+        if (!this._selectedPageId && pagesData.length > 0) {
+            this._selectedPageId = pagesData[0].id;
+            this.log("🎯 Set default selectedPageId", { new: this._selectedPageId });
+        }
+        const state = {
+            pages: pagesData,
+            selectedPageId: this._selectedPageId,
+        };
+        this.log("📦 Final state", state);
+        return state;
+    }
+    async createTab(url = "about:blank") {
+        try {
+            this.log("🆕 Creating new tab", { url });
+            const page = await this.context.newPage(); // This will trigger the 'page' event
+            if (url !== "about:blank") {
+                await page.goto(url, { waitUntil: "domcontentloaded" });
+            }
+            for (const [stableTabId, pageInfo] of this.pages.entries()) {
+                if (pageInfo.page === page) {
+                    this._selectedPageId = stableTabId;
+                    this.log("✅ New tab created and selected", { stableTabId, url });
+                    break;
+                }
+            }
+            await this.syncState();
+        }
+        catch (error) {
+            this.log("❌ Error creating tab", { error });
+        }
+    }
+    async closeTab(stableTabId) {
+        try {
+            this.log("🗑️ Closing tab", { stableTabId });
+            const pageInfo = this.pages.get(stableTabId);
+            if (pageInfo) {
+                await pageInfo.page.close(); // This will trigger the 'close' event
+            }
+            else {
+                this.log("⚠️ Page not found for closing", { stableTabId });
+            }
+        }
+        catch (error) {
+            this.log("❌ Error closing tab", { error });
+        }
+    }
+    async selectTab(stableTabId) {
+        try {
+            this.log("🎯 Selecting tab", { stableTabId });
+            const pageInfo = this.pages.get(stableTabId);
+            if (pageInfo) {
+                this._selectedPageId = stableTabId;
+                await pageInfo.page.bringToFront();
+                this.log("✅ Tab selected successfully", { stableTabId });
+                await this.syncState();
+            }
+            else {
+                this.log("⚠️ Page not found for selection", { stableTabId });
+            }
+        }
+        catch (error) {
+            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", {
+            selectedPageId: this._selectedPageId,
+            found: !!pageInfo,
+            url: pageInfo?.page.url(),
+        });
+        return pageInfo?.page || null;
+    }
+    destroy() {
+        this.log("💥 Destroying RemoteBrowserService");
+        this.context.removeAllListeners("page");
+        for (const [, pageInfo] of this.pages.entries()) {
+            pageInfo.page.removeAllListeners(); // Remove all listeners from each page
+        }
+        this.pages.clear();
+        this._selectedPageId = null;
+        this.removeAllListeners();
+    }
 }