pw-automation-framework 2.0.1

package/src/core/handlers/DropdownHandler.ts

@@ -0,0 +1,438 @@
+import { Page } from "playwright";
+import { ActionResponse, TestCaseConfig } from "../../types/types";
+import { pass, fail } from "../../utils/response";
+import { buildLocatorString } from "../../utils/locatorHelper";
+import { BaseHandler } from "./BaseHandler";
+
+/**
+ * DropdownHandler
+ * ===============
+ * ROOT CAUSE OF DROPDOWN DELAY (fixed):
+ * - Previous: using networkidle wait after every action
+ * - Fix: Playwright's selectOption() is synchronous once visible.
+ *   We waitFor visible then immediately selectOption. No extra waits.
+ *
+ * Also supports:
+ * - Custom dropdowns (non-<select>) via click-then-click pattern
+ * - Multi-select
+ * - Autocomplete / combobox
+ */
+export class DropdownHandler extends BaseHandler {
+  constructor(tConfig: TestCaseConfig, page: Page) { super(tConfig, page); }
+
+  getActions() {
+    return {
+      selectdropdown:         this.selectDropdown.bind(this),
+      selectMuiDropdown:      this.selectMuiDropdown.bind(this),
+      selectbyindex:          this.selectByIndex.bind(this),
+      selectbyvalue:          this.selectByValue.bind(this),
+      multiselect:            this.multiSelect.bind(this),
+      getdropdownoptions:     this.getDropdownOptions.bind(this),
+      getselectedoption:      this.getSelectedOption.bind(this),
+      selectcustomdropdown:   this.selectCustomDropdown.bind(this),
+      selectautocomplete:     this.selectAutocomplete.bind(this),
+    };
+  }
+ async selectMuiDropdown(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, value] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator || !value) {
+    return fail("selectMuiDropdown needs: strategy, locator, value", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const dropdown = this.page.locator(ls);
+
+   
+    await dropdown.waitFor({ state: "visible", timeout: this.timeout });
+    await this.highlight(ls, "select", `Opening dropdown`);
+    await dropdown.click();
+
+   
+    const option = this.page.locator(`//li[normalize-space()="${value}"]`);
+
+    await option.waitFor({ state: "visible", timeout: this.timeout });
+    await option.click();
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected "${value}" from ${displayLabel}`,
+      sc,
+      { expected_result: `"${value}" selected successfully in "${displayLabel}"` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectMuiDropdown "${value}" in ${displayLabel} — ${error.message}`;
+
+    return fail(
+      errorMsg,
+      undefined,
+      sc,
+      { expected_result: `"${value}" selected successfully in "${displayLabel}"` }
+    );
+  }
+}
+  // tSetup.selectDropdown('xpath', '//select[...]', 'Option Label')
+  // ✅ OPTIMIZED: no networkidle, just waitFor visible then selectOption immediately
+  async selectDropdown(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, value] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator || !value) {
+    return fail(
+      "selectDropdown needs: strategy, locator, visibleText",
+      "Missing args"
+    );
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    // ✅ Highlight before action
+    await this.highlight(ls, "select", `Selecting: "${value}"`);
+
+    const byLabel = el.selectOption({ label: value }, { timeout: this.timeout });
+
+    const byValue = el.selectOption({ value }, { timeout: this.timeout });
+
+    const byPartialText = (async () => {
+      const options = await el.locator("option").all();
+      for (const opt of options) {
+        const txt = (await opt.textContent() ?? "").trim();
+        if (txt.toLowerCase().includes(value.toLowerCase())) {
+          const val = await opt.getAttribute("value");
+          if (!val) throw new Error(`Option "${value}" has no value`);
+          return el.selectOption({ value: val }, { timeout: this.timeout });
+        }
+      }
+      throw new Error(`Option "${value}" not found`);
+    })();
+
+    await Promise.any([byLabel, byValue, byPartialText]);
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected "${value}" from ${displayLabel}`,
+      sc,
+      { expected_result: `"${value}" selected successfully in "${displayLabel}"` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectDropdown "${value}" in ${displayLabel} — ${error.message}`;
+
+    return fail(
+      errorMsg,
+      undefined,
+      sc,
+      { expected_result: `"${value}" selected successfully in "${displayLabel}"` }
+    );
+  }
+}
+  // tSetup.selectByIndex('xpath', '//select[...]', '2')
+  async selectByIndex(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, indexStr] = args;
+  const displayLabel = slabel || "unknown";
+  const index = parseInt(indexStr, 10);
+
+  if (!strategy || !locator || isNaN(index)) {
+    return fail("selectByIndex needs: strategy, locator, index", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "select", `Selecting index: ${index}`);
+    await el.selectOption({ index }, { timeout: this.timeout });
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected index ${index} in ${displayLabel}`,
+      sc,
+      { expected_result: `Index ${index} selected successfully in "${displayLabel}"` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectByIndex ${index} in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+
+  async selectByValue(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, value] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator || !value) {
+    return fail("selectByValue needs: strategy, locator, value", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "select", `Selecting value: "${value}"`);
+    await el.selectOption({ value }, { timeout: this.timeout });
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected value "${value}" in ${displayLabel}`,
+      sc,
+      { expected_result: `"${value}" selected successfully in "${displayLabel}"` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectByValue "${value}" in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+
+ async multiSelect(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, ...values] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator || values.length === 0) {
+    return fail("multiSelect needs: strategy, locator, ...values", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "select", `Selecting: ${values.join(", ")}`);
+    await el.selectOption(values.map(v => ({ label: v })), { timeout: this.timeout });
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Multi-selected [${values.join(", ")}] in ${displayLabel}`,
+      sc,
+      { expected_result: `Values [${values.join(", ")}] selected in "${displayLabel}"` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed multiSelect in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+async getDropdownOptions(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, storeKey] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("getDropdownOptions needs: strategy, locator", "Missing args");
+  }
+
+  try {
+    const el = this.page.locator(buildLocatorString(strategy, locator));
+    await el.waitFor({ state: "attached", timeout: this.timeout });
+
+    const texts = await el.locator("option").allTextContents();
+    if (storeKey) this.testData.set(storeKey, texts);
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Options: [${texts.join(", ")}] in ${displayLabel}`,
+      sc,
+      { options: texts }
+    );
+
+  } catch (error: any) {
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed getDropdownOptions in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+
+  async getSelectedOption(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator, storeKey] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("getSelectedOption needs: strategy, locator", "Missing args");
+  }
+
+  try {
+    const el = this.page.locator(buildLocatorString(strategy, locator));
+    await el.waitFor({ state: "attached", timeout: this.timeout });
+
+    const text = ((await el.locator("option:checked").textContent()) ?? "").trim();
+    if (storeKey) this.testData.set(storeKey, text);
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected: "${text}" in ${displayLabel}`,
+      sc,
+      { selected: text }
+    );
+
+  } catch (error: any) {
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed getSelectedOption in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+
+  async selectCustomDropdown(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [ts, tl, os, ol] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!ts || !tl || !os || !ol) {
+    return fail("selectCustomDropdown needs locators", "Missing args");
+  }
+
+  try {
+    const trigger = this.page.locator(buildLocatorString(ts, tl));
+    await trigger.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(buildLocatorString(ts, tl), "select", "Opening dropdown");
+    await trigger.click();
+
+    const option = this.page.locator(buildLocatorString(os, ol));
+    await option.waitFor({ state: "visible", timeout: this.timeout });
+    await option.click();
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`Custom dropdown selected in ${displayLabel}`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectCustomDropdown in ${displayLabel} — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+
+  /**
+   * tSetup.selectAutocomplete('xpath', '//input[@id="search"]', 'New York', 'xpath', '//li[text()="New York"]')
+   * Types into autocomplete input, waits for suggestion, clicks it
+   */
+  async selectAutocomplete(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [is, il, text, os, ol] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!is || !il || !text) {
+    return fail("selectAutocomplete needs input locator & text", "Missing args");
+  }
+
+  try {
+    const input = this.page.locator(buildLocatorString(is, il));
+    await input.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(buildLocatorString(is, il), "input", `Typing: "${text}"`);
+
+    await input.clear();
+    await input.pressSequentially(text, { delay: 80 });
+
+    if (os && ol) {
+      const option = this.page.locator(buildLocatorString(os, ol));
+      await option.waitFor({ state: "visible", timeout: this.timeout });
+      await option.click();
+    } else {
+      await input.press("Enter");
+    }
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`Autocomplete selected: "${text}"`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectAutocomplete "${text}" — ${error.message}`;
+
+    return fail(errorMsg, undefined, sc);
+  }
+}
+}

package/src/core/handlers/InputHandler.ts

@@ -0,0 +1,192 @@
+import { Page } from "playwright";
+import { ActionResponse, TestCaseConfig } from "../../types/types";
+import { pass, fail } from "../../utils/response";
+import { buildLocatorString } from "../../utils/locatorHelper";
+import { BaseHandler } from "./BaseHandler";
+import { failElementNotFound } from "../../utils/response";
+
+export class InputHandler extends BaseHandler {
+  constructor(tConfig: TestCaseConfig, page: Page) { super(tConfig, page); }
+
+  getActions() {
+    return {
+      entertext: this.enterText.bind(this),
+      typetext: this.typeText.bind(this),
+      cleartext: this.clearText.bind(this),
+      appendtext: this.appendText.bind(this),
+      getinputvalue: this.getInputValue.bind(this),
+      setinputvalue: this.setInputValueByJS.bind(this),
+      uploadfile: this.uploadFile.bind(this),
+      enteriframe: this.enterTextInFrame.bind(this),
+    };
+  }
+
+  // tSetup.enterText('xpath', '//input[...]', 'hello@mail.com')
+  async enterText(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, rawText] = args;
+    const text = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    const displayLabel = label || 'unknown';
+
+    if (!strategy || !locator) return fail("enterText needs: strategy, locator, text", "Missing args");
+    const ls = buildLocatorString(strategy, locator);
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      // ✅ Highlight field before entering text
+      await this.highlight(ls, "input", `Entering: "${text}"`);
+      await el.clear();
+      await el.fill(text);
+      await this.unhighlight();
+      const sc = await this.shots.onPass(this.page);
+      return pass(
+        `Entered "${text}" into ${displayLabel}`,
+        sc,
+        { expected_result: `"${text}" entered successfully in "${displayLabel}"` }
+      );
+    } catch (error: any) {
+      await this.unhighlight();
+      const sc = await this.shots.onFail(this.page);
+    //   const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+    //   const errorMsg = isNotFound
+    //     ? `"${displayLabel}" not found`
+    //     : `Failed enterText into ${displayLabel} — ${error.message}`;
+    //   return fail(errorMsg, undefined, sc, { expected_result: `"${text}" entered successfully in "${displayLabel}"` });
+    // }
+        const msg = error.message.toLowerCase();
+    if (msg.includes("waiting for locator") || msg.includes("timeout") || msg.includes("no element")) {
+      return failElementNotFound(displayLabel, sc);
+    }
+    return fail(`Failed enterText into ${displayLabel} — ${error.message}`, undefined, sc, { expected_result: `"${text}" entered successfully in "${displayLabel}"` });
+      }
+    }
+
+  // tSetup.typeText('xpath', '//input[...]', 'hello') — real char-by-char typing
+  async typeText(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, rawText, delayStr] = args;
+    const text = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    const delay = parseInt(delayStr || "50", 10);
+    if (!strategy || !locator) return fail("typeText needs: strategy, locator, text, [delay]", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.pressSequentially(text, { delay });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Typed "${text}" into ${label || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed typeText into ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.clearText('xpath', '//input[...]')
+  async clearText(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator] = args;
+    if (!strategy || !locator) return fail("clearText needs: strategy, locator", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.clear();
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Cleared ${label || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed clearText ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.appendText('xpath', '//input[...]', ' extra')
+  async appendText(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, rawText] = args;
+    const text = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    if (!strategy || !locator) return fail("appendText needs: strategy, locator, text", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.focus();
+      await this.page.keyboard.press("End");
+      await el.pressSequentially(text, { delay: 30 });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Appended "${text}" to ${label || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed appendText into ${label || 'unknown'}]`, error.message, sc);
+    }
+  }
+
+  // tSetup.getInputValue('xpath', '//input[...]', 'storeKey')
+  async getInputValue(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, storeKey] = args;
+    if (!strategy || !locator) return fail("getInputValue needs: strategy, locator, [storeKey]", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "attached", timeout: this.timeout });
+      const value = await el.inputValue();
+      if (storeKey) this.testData.set(storeKey, value);
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Input value: "${value}"`, sc, { value });
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed getInputValue ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.setInputValue('xpath', '//input[...]', 'value') — JS set (bypasses React controlled input)
+  async setInputValueByJS(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, rawText] = args;
+    const value = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    const text = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    if (!strategy || !locator) return fail("setInputValue needs: strategy, locator, text", "Missing args");
+    const ls = buildLocatorString(strategy, locator);
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await this.highlight(ls, "input", `Set: "${value}"`);
+      await el.evaluate((node: HTMLInputElement, val: string) => {
+        const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")?.set;
+        setter?.call(node, val);
+        node.dispatchEvent(new Event("input", { bubbles: true }));
+        node.dispatchEvent(new Event("change", { bubbles: true }));
+      }, text);
+      await this.unhighlight();
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Set input value "${text}" via JS ${label || 'unknown'}`, sc);
+    } catch (error: any) {
+      await this.unhighlight();
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed setInputValue ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.uploadFile('xpath', '//input[@type="file"]', '/path/to/file.pdf')
+  async uploadFile(args: string[], label?: string): Promise<ActionResponse> {
+    const [strategy, locator, filePath] = args;
+    if (!strategy || !locator || !filePath) return fail("uploadFile needs: strategy, locator, filePath", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.setInputFiles(filePath);
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Uploaded file: "${filePath}"`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed uploadFile ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.enterIframe('iframe[name="myFrame"]', 'xpath', '//input[...]', 'value')
+  async enterTextInFrame(args: string[], label?: string): Promise<ActionResponse> {
+    const [frameSelector, strategy, locator, rawText] = args;
+    const text = String(this.testData.resolve(rawText) ?? rawText ?? "");
+    if (!frameSelector || !strategy || !locator) return fail("enterIframe needs: frameSelector, strategy, locator, text", "Missing args");
+    try {
+      const frame = this.page.frameLocator(frameSelector);
+      const el = frame.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.fill(text);
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Entered "${text}" in frame [${frameSelector}] → [${label || 'unknown'}]`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed enterIframe ${label || 'unknown'}`, error.message, sc);
+    }
+  }
+}

package/src/core/registry/ActionRegistry.ts

@@ -0,0 +1,31 @@
+import { ActionResponse, ActionHandler, IActionHandler } from "../../types/types";
+import { Logger } from "../../utils/logger";
+
+const log = Logger.create("ActionRegistry");
+
+export class ActionRegistry {
+  private handlers: Map<string, (args: string[], label?: string) => Promise<ActionResponse | undefined>> = new Map();
+
+  register(handler: IActionHandler): void {
+    for (const [name, fn] of Object.entries(handler.getActions())) {
+      const key = name.toLowerCase();
+      if (this.handlers.has(key)) log.warn(`Action "${key}" overwritten`);
+      this.handlers.set(key, fn);
+    }
+  }
+
+  async execute(action: string, args: string[], label?: string): Promise<ActionResponse | undefined> {
+    const handler = this.handlers.get(action.toLowerCase());
+    if (!handler) {
+      log.error(`Unknown action: "${action}"`);
+      return undefined;
+    }
+    if (label =='' || label == undefined){
+      return handler(args);}
+    else{
+      return handler(args, label);}
+  }
+
+  has(action: string): boolean { return this.handlers.has(action.toLowerCase()); }
+  listActions(): string[] { return Array.from(this.handlers.keys()).sort(); }
+}