linkedin-automation-cli 1.0.0

package/src/agent/action-executor.ts

@@ -0,0 +1,203 @@
+/**
+ * Action Executor Module
+ *
+ * Executes action plans using Playwright browser automation.
+ * Maps element IDs from DOM representation to actual click coordinates.
+ */
+
+import type { Page } from 'playwright';
+import type { Action, DOMRepresentation, DOMElement, ExecutedAction } from './types';
+
+/**
+ * Result of executing a single action
+ */
+export interface ExecutionResult {
+  /** Whether the action executed successfully */
+  success: boolean;
+  /** Error message if the action failed */
+  error?: string;
+}
+
+/**
+ * Executes actions on a Playwright page using DOM representation
+ */
+export class ActionExecutor {
+  private readonly page: Page;
+  private readonly dom: DOMRepresentation;
+
+  /**
+   * Creates a new ActionExecutor
+   * @param page - Playwright page instance
+   * @param dom - DOM representation with element bounding boxes
+   */
+  constructor(page: Page, dom: DOMRepresentation) {
+    this.page = page;
+    this.dom = dom;
+  }
+
+  /**
+   * Execute a single action
+   * @param action - The action to execute
+   * @returns Promise<ExecutionResult> with success status
+   */
+  async execute(action: Action): Promise<ExecutionResult> {
+    try {
+      switch (action.type) {
+        case 'click':
+          return await this.executeClick(action.elementId);
+        case 'type':
+          return await this.executeType(action.elementId, action.text);
+        case 'wait':
+          return await this.executeWait(action.durationMs);
+        case 'navigate':
+          return await this.executeNavigate(action.url);
+        default:
+          return {
+            success: false,
+            error: `Unknown action type: ${(action as Action).type}`,
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Execute a list of actions sequentially
+   * @param actions - Array of actions to execute
+   * @returns Promise<ExecutedAction[]> with execution results and timestamps
+   */
+  async executeAll(actions: Action[]): Promise<ExecutedAction[]> {
+    const executedActions: ExecutedAction[] = [];
+
+    for (const action of actions) {
+      // Log the action before execution
+      console.log(`Executing action: ${action.description}`);
+
+      const result = await this.execute(action);
+
+      const executedAction: ExecutedAction = {
+        action,
+        success: result.success,
+        timestamp: new Date(),
+        error: result.error,
+      };
+
+      executedActions.push(executedAction);
+
+      // Stop on first failure
+      if (!result.success) {
+        console.error(`Action failed: ${result.error}`);
+        break;
+      }
+
+      // Add 500ms delay between actions (except after the last one)
+      if (actions.indexOf(action) < actions.length - 1) {
+        await this.page.waitForTimeout(500);
+      }
+    }
+
+    return executedActions;
+  }
+
+  /**
+   * Find element by ID in the DOM representation
+   * @param elementId - The element ID to find
+   * @returns DOMElement or undefined if not found
+   */
+  private findElement(elementId: string): DOMElement | undefined {
+    return this.dom.elements.find((el) => el.id === elementId);
+  }
+
+  /**
+   * Execute a click action
+   * @param elementId - ID of the element to click
+   * @returns ExecutionResult
+   */
+  private async executeClick(elementId: string): Promise<ExecutionResult> {
+    const element = this.findElement(elementId);
+
+    if (!element) {
+      return {
+        success: false,
+        error: `Element not found: ${elementId}`,
+      };
+    }
+
+    // Calculate center of bounding box
+    const centerX = element.bbox.x + element.bbox.width / 2;
+    const centerY = element.bbox.y + element.bbox.height / 2;
+
+    // Perform the click at the calculated coordinates
+    await this.page.mouse.click(centerX, centerY);
+
+    return { success: true };
+  }
+
+  /**
+   * Execute a type action
+   * @param elementId - ID of the input element
+   * @param text - Text to type
+   * @returns ExecutionResult
+   */
+  private async executeType(elementId: string, text: string): Promise<ExecutionResult> {
+    const element = this.findElement(elementId);
+
+    if (!element) {
+      return {
+        success: false,
+        error: `Element not found: ${elementId}`,
+      };
+    }
+
+    // Click element first to focus
+    const centerX = element.bbox.x + element.bbox.width / 2;
+    const centerY = element.bbox.y + element.bbox.height / 2;
+
+    await this.page.mouse.click(centerX, centerY);
+
+    // Wait 100ms for focus to settle
+    await this.page.waitForTimeout(100);
+
+    // Type the text
+    await this.page.keyboard.type(text);
+
+    return { success: true };
+  }
+
+  /**
+   * Execute a wait action
+   * @param durationMs - Duration to wait in milliseconds
+   * @returns ExecutionResult
+   */
+  private async executeWait(durationMs: number): Promise<ExecutionResult> {
+    await this.page.waitForTimeout(durationMs);
+    return { success: true };
+  }
+
+  /**
+   * Execute a navigate action
+   * @param url - URL to navigate to
+   * @returns ExecutionResult
+   */
+  private async executeNavigate(url: string): Promise<ExecutionResult> {
+    await this.page.goto(url, {
+      waitUntil: 'domcontentloaded',
+      timeout: 30000,
+    });
+    return { success: true };
+  }
+}
+
+/**
+ * Create a new ActionExecutor instance
+ * @param page - Playwright page instance
+ * @param dom - DOM representation with element bounding boxes
+ * @returns ActionExecutor instance
+ */
+export function createActionExecutor(page: Page, dom: DOMRepresentation): ActionExecutor {
+  return new ActionExecutor(page, dom);
+}