automation_model 1.0.61 → 1.0.63

package/bin/auto_page.d.ts

@@ -1,3 +1,3 @@
-export function initContext(path: any, doNavigate?: boolean, headless?: boolean): Promise<any>;
+export function initContext(path: any, doNavigate?: boolean, headless?: boolean, world?: null): Promise<any>;
 export function navigate(path?: string): Promise<void>;
 export function closeContext(): Promise<void>;

package/bin/auto_page.js

@@ -1,6 +1,7 @@
 import { browserManager } from "./browser_manager.js";
 import { getContext } from "./init_browser.js";
-
+import fs from "fs";
+import path from "path";
 let context = null;
 const navigate = async (path = "") => {
   let url = null;
@@ -12,12 +13,35 @@ const navigate = async (path = "") => {
   await context.stable.goto(url);
   await context.stable.waitForPageLoad();
 };
-
-const initContext = async (path, doNavigate = true, headless = false) => {
+const _findEmptyFolder = (folder) => {
+  if (!folder) {
+    folder = "./runs";
+  }
+  if (!fs.existsSync(folder)) {
+    fs.mkdirSync(folder);
+  }
+  let nextIndex = 1;
+  while (fs.existsSync(path.join(folder, nextIndex.toString()))) {
+    nextIndex++;
+  }
+  return path.join(folder, nextIndex.toString());
+};
+const initContext = async (path, doNavigate = true, headless = false, world = null) => {
   if (context) {
     return context;
   }
   context = await getContext(null, headless);
+
+  if (world) {
+    world.screenshot = true;
+    const reportFolder = _findEmptyFolder();
+    if (world.attach) {
+      world.attach(reportFolder, { mediaType: "text/plain" });
+    }
+    world.screenshotPath = reportFolder;
+    context.reportFolder = reportFolder;
+  }
+
   if (doNavigate) {
     await navigate(path);
   }

package/bin/browser_manager.d.ts

@@ -7,9 +7,9 @@ declare class BrowserManager {
     getBrowser(headless?: boolean): Promise<any>;
 }
 declare class Browser {
-    browser: import("playwright-core").Browser | null;
-    context: import("playwright-core").BrowserContext | null;
-    page: import("playwright-core").Page | null;
+    browser: any;
+    context: any;
+    page: any;
     init(headless?: boolean): Promise<void>;
     close(): Promise<void>;
 }

package/bin/init_browser.js

@@ -17,6 +17,7 @@ const getContext = async function (environment = null, headless = false, logger
   context.playContext = browser.context;
   context.page = browser.page;
   context.environment = environment;
+
   context.stable = new StableBrowser(context.browser, context.page, logger);
   await _initCookies(context);
   return context;
@@ -48,7 +49,8 @@ const initEnvoronment = function () {
       const envObject = JSON.parse(data);
       //console.log("envObject", envObject);
       Object.assign(environment, envObject);
-      console.log("env", environment);
+      //console.log("env", environment);
+      console.log("Base url: " + environment.baseUrl);
     } catch (err) {
       console.error("Error reading env.json", err);
     }

package/bin/stable_browser.d.ts

@@ -9,24 +9,24 @@ export class StableBrowser {
     _locateElementByText(scope: any, text1: any, tag1: any, regex?: boolean, _params?: null): Promise<any>;
     _collectLocatorInformation(selectorHierarchy: any, index: number | undefined, scope: any, foundLocators: any, _params: any): Promise<void>;
     _locate(selectors: any, info: any, _params: any, timeout?: number): Promise<any>;
-    click(selector: any, _params?: null, options?: {}): Promise<{
+    click(selector: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
     }>;
-    selectOption(selector: any, values: any, _params?: null, options?: {}): Promise<{
+    selectOption(selector: any, values: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
     }>;
-    fill(selector: any, value: any, enter?: boolean, _params?: null, options?: {}): Promise<{
+    fill(selector: any, value: any, enter?: boolean, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
         value: any;
     }>;
-    getText(selector: any, _params?: null, options?: {}, info?: {}): Promise<any>;
-    containsPattern(selector: any, pattern: any, text: any, _params?: null, options?: {}): Promise<{
+    getText(selector: any, _params?: null, options?: {}, info?: {}, world?: null): Promise<any>;
+    containsPattern(selector: any, pattern: any, text: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
@@ -34,20 +34,20 @@ export class StableBrowser {
         pattern: any;
         foundText: any;
     }>;
-    containsText(selector: any, text: any, _params?: null, options?: {}): Promise<{
+    containsText(selector: any, text: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
         value: any;
         foundText: any;
     }>;
-    _screenShot(options?: {}): Promise<void>;
-    verifyElementExistInPage(selector: any, _params?: null, options?: {}): Promise<{
+    _screenShot(options?: {}, world?: null): Promise<void>;
+    verifyElementExistInPage(selector: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
     }>;
-    analyzeTable(selector: any, query: any, operator: any, value: any, _params?: null, options?: {}): Promise<{
+    analyzeTable(selector: any, query: any, operator: any, value: any, _params?: null, options?: {}, world?: null): Promise<{
         log: any[];
         operation: string;
         selector: any;
@@ -56,5 +56,6 @@ export class StableBrowser {
         operator: any;
         value: any;
     }>;
-    waitForPageLoad(options?: {}): Promise<void>;
+    waitForPageLoad(options?: {}, world?: null): Promise<void>;
+    _reportToWorld(world: any, properties?: {}): void;
 }

package/bin/stable_browser.js

@@ -1,6 +1,7 @@
 import reg_parser from "regex-parser";
 import { expect } from "@playwright/test";
 import fs from "fs";
+import path from "path";
 import { getTableCells } from "./table_analyze.js";
 let configuration = null;
 class StableBrowser {
@@ -186,71 +187,75 @@ class StableBrowser {
     throw new Error("failed to locate first element no elements found, " + JSON.stringify(info));
   }
 
-  async click(selector, _params = null, options = {}) {
+  async click(selector, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "click";
     info.selector = selector;
-
+    this._reportToWorld(world, { command: "click", params: _params, selector: selector });
     try {
       let element = await this._locate(selector, info, _params);
 
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       try {
         await element.click({ timeout: 5000 });
       } catch (e) {
         info.log.push("click failed, will try force click");
+        this._reportToWorld(world, { message: "click failed, will try force click" });
         await element.click({ timeout: 10000, force: true });
       }
+      this._reportToWorld(world, { result: "success", info: info });
       await this.waitForPageLoad();
       return info;
     } catch (e) {
       this.logger.error("click failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
-
-      this.logger.info("click failed, will try next selector");
     }
   }
 
-  async selectOption(selector, values, _params = null, options = {}) {
+  async selectOption(selector, values, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "selectOptions";
     info.selector = selector;
-
+    this._reportToWorld(world, { command: "select", values, params: _params, selector: selector });
     try {
       let element = await this._locate(selector, info, _params);
 
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       try {
         await element.selectOption(values, { timeout: 5000 });
       } catch (e) {
         info.log.push("selectOption failed, will try force");
+        this._reportToWorld(world, { message: "select failed, will try force select" });
         await element.selectOption(values, { timeout: 10000, force: true });
       }
       await this.waitForPageLoad();
       return info;
     } catch (e) {
       this.logger.error("selectOption failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
 
       this.logger.info("click failed, will try next selector");
     }
   }
 
-  async fill(selector, value, enter = false, _params = null, options = {}) {
+  async fill(selector, value, enter = false, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "fill";
     info.selector = selector;
     info.value = value;
+    this._reportToWorld(world, { command: "fill", value, enter, params: _params, selector: selector });
     try {
       let element = await this._locate(selector, info, _params);
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       await element.fill(value, { timeout: 10000 });
       await element.dispatchEvent("change");
       if (enter) {
@@ -260,18 +265,19 @@ class StableBrowser {
       return info;
     } catch (e) {
       this.logger.error("fill failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
     }
   }
 
-  async getText(selector, _params = null, options = {}, info = {}) {
+  async getText(selector, _params = null, options = {}, info = {}, world = null) {
     if (!info.log) {
       info.log = [];
     }
     let element = await this._locate(selector, info, _params);
-    await this._screenShot(options);
+    await this._screenShot(options, world);
     try {
       return await element.innerText();
     } catch (e) {
@@ -279,7 +285,7 @@ class StableBrowser {
       return await element.textContent();
     }
   }
-  async containsPattern(selector, pattern, text, _params = null, options = {}) {
+  async containsPattern(selector, pattern, text, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "containsPattern";
@@ -287,8 +293,9 @@ class StableBrowser {
     info.value = text;
     info.pattern = pattern;
     let foundText = null;
+    this._reportToWorld(world, { command: "contains", pattern, text, params: _params, selector: selector });
     try {
-      foundText = await this.getText(selector, _params, options, info);
+      foundText = await this.getText(selector, _params, options, info, world);
       let escapedText = text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
       pattern = pattern.replace("{text}", escapedText);
       let regex = new RegExp(pattern, "m");
@@ -300,20 +307,21 @@ class StableBrowser {
     } catch (e) {
       this.logger.error("verify element contains text failed " + JSON.stringify(info));
       this.logger.error("found text " + foundText + " pattern " + pattern);
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
     }
   }
 
-  async containsText(selector, text, _params = null, options = {}) {
+  async containsText(selector, text, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "containsText";
     info.selector = selector;
     info.value = text;
     try {
-      let foundText = await this.getText(selector, _params, options, info);
+      let foundText = await this.getText(selector, _params, options, info, world);
       if (!foundText.includes(text)) {
         info.foundText = foundText;
         throw new Error("element doesn't contain text " + text);
@@ -321,35 +329,51 @@ class StableBrowser {
       return info;
     } catch (e) {
       this.logger.error("verify element contains text failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
     }
   }
-  async _screenShot(options = {}) {
-    if (options.screenshot) {
+  async _screenShot(options = {}, world = null) {
+    if (world && world.attach && world.screenshot && world.screenshotPath) {
+      if (!fs.existsSync(world.screenshotPath)) {
+        fs.mkdirSync(world.screenshotPath, { recursive: true });
+      }
+      let nextIndex = 1;
+      while (fs.existsSync(path.join(world.screenshotPath, nextIndex + ".png"))) {
+        nextIndex++;
+      }
+      const screenshotPath = path.join(world.screenshotPath, nextIndex + ".png");
+      await this.page.screenshot({ path: screenshotPath });
+      await world.attach(JSON.stringify({ path: screenshotPath }), {
+        mediaType: "application/json",
+      });
+    } else if (options.screenshot) {
       await this.page.screenshot({ path: options.screenshotPath });
     }
   }
-  async verifyElementExistInPage(selector, _params = null, options = {}) {
+  async verifyElementExistInPage(selector, _params = null, options = {}, world = null) {
     await new Promise((resolve) => setTimeout(resolve, 2000));
     const info = {};
     info.log = [];
     info.operation = "verify";
     info.selector = selector;
+    this._reportToWorld(world, { command: "verify", params: _params, selector: selector });
     try {
       const element = await this._locate(selector, info, _params);
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       await expect(element).toHaveCount(1, { timeout: 10000 });
       return info;
     } catch (e) {
       this.logger.error("verify failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
     }
   }
-  async analyzeTable(selector, query, operator, value, _params = null, options = {}) {
+  async analyzeTable(selector, query, operator, value, _params = null, options = {}, world = null) {
     const info = {};
     info.log = [];
     info.operation = "analyzeTable";
@@ -359,9 +383,17 @@ class StableBrowser {
     info.query_fixed = query;
     info.operator = operator;
     info.value = value;
+    this._reportToWorld(world, {
+      command: "analyzeTable",
+      query,
+      operator,
+      value,
+      params: _params,
+      selector: selector,
+    });
     try {
       let table = await this._locate(selector, info, _params);
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       const cells = await getTableCells(this.page, table, query, info);
 
       if (cells.error) {
@@ -436,13 +468,15 @@ class StableBrowser {
       return info;
     } catch (e) {
       this.logger.error("analyzeTable failed " + JSON.stringify(info));
+      this._reportToWorld(world, { result: "failed", info: info, error: e });
       Object.assign(e, { info: info });
-      await this._screenShot(options);
+      await this._screenShot(options, world);
       throw e;
     }
   }
-  async waitForPageLoad(options = {}) {
+  async waitForPageLoad(options = {}, world = null) {
     let timeout = 10000;
+    this._reportToWorld(world, { command: "waitForPageLoade" });
     if (!configuration) {
       try {
         if (fs.existsSync("ai_config.json")) {
@@ -473,7 +507,13 @@ class StableBrowser {
       console.log("waitForPageLoad error, ignored");
     }
     await new Promise((resolve) => setTimeout(resolve, 2000));
-    await this._screenShot(options);
+    await this._screenShot(options, world);
+  }
+  _reportToWorld(world, properties = {}) {
+    if (!world || !world.attach) {
+      return;
+    }
+    world.attach(JSON.stringify(properties), { mediaType: "application/json" });
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automation_model",
-  "version": "1.0.61",
+  "version": "1.0.63",
   "description": "An automation infrastructure module to be use for generative AI automation projects.",
   "main": "bin/index.js",
   "type": "module",