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

package/bin/client/recorderv3/services.js

@@ -2,162 +2,439 @@ 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",
+            },
         });
-
-        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;
-  }
+        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.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");
+        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 });
+            }
+            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 {
+            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 });
+                }
+                pagesData.push({
+                    id: stableTabId,
+                    title: await pageInfo.page.title(),
+                    url: pageInfo.page.url(),
+                    wsDebuggerUrl: wsDebuggerUrl, // Use the constructed URL
+                });
+            }
+            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 });
+        }
+    }
+    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();
+    }
 }