@stubber/virtual-worker 1.5.1 → 1.5.3

package/app/commands/browser/browser_extract_html.js

@@ -22,11 +22,14 @@ export const browser_extract_html = async (params, stubber_context) => {
     const { locator } = params || {};
 
     if (locator) {
-      const target = page.locator(locator);
-      if (!(await target.count())) {
+      const target = await page.locator(locator).all();
+      if (!target.length) {
         return create_error_conceptual({ message: "Locator did not match any elements", details: { locator } });
       }
-      html_content = await target.evaluate((el) => el.outerHTML);
+      for (const element of target) {
+        const outer_html = await element.evaluate((el) => el.outerHTML);
+        html_content += outer_html; // Concatenate HTML of all matched elements
+      }
     } else {
       html_content = await page.content();
     }

package/app/commands/browser/browser_extract_markdown.js

@@ -0,0 +1,45 @@
+import { create_error_conceptual } from "#app/functions/create_error_conceptual.js";
+import { create_error_technical } from "#app/functions/create_error_technical.js";
+import { create_success } from "#root/app/functions/create_success.js";
+import { get_chromium_page } from "../../helpers/get_chromium_page.js";
+import { NodeHtmlMarkdown as node_html_md } from "node-html-markdown";
+
+/**
+ *
+ * @param {Object} params
+ * @param {string} [params.locator] - Optional locator to extract HTML from a specific element
+ */
+export const browser_extract_markdown = async (params, stubber_context) => {
+  // Get the Chromium page
+  const page_result = await get_chromium_page(params, stubber_context);
+  if (!page_result.success) {
+    return page_result;
+  }
+
+  const page = page_result.payload;
+  let html_content = "";
+  let markdown_content = "";
+
+  try {
+    const { locator } = params || {};
+
+    if (locator) {
+      const target = await page.locator(locator).all();
+      if (!target.length) {
+        return create_error_conceptual({ message: "Locator did not match any elements", details: { locator } });
+      }
+      for (const element of target) {
+        const outer_html = await element.evaluate((el) => el.outerHTML);
+        html_content += outer_html; // Concatenate HTML of all matched elements
+      }
+      markdown_content = node_html_md.translate(html_content);
+    } else {
+      html_content = await page.content();
+      markdown_content = node_html_md.translate(html_content);
+    }
+  } catch (error) {
+    return create_error_technical(error);
+  }
+
+  return create_success({ message: `Markdown content retrieved successfully`, payload: { markdown_content } });
+};

package/app/commands/browser/browser_find.js

@@ -0,0 +1,49 @@
+import { create_error_conceptual } from "#app/functions/create_error_conceptual.js";
+import { create_error_technical } from "#app/functions/create_error_technical.js";
+import { create_success } from "#root/app/functions/create_success.js";
+import { get_chromium_page } from "../../helpers/get_chromium_page.js";
+
+/**
+ * Used to find contents in the page and returns surrounding HTML.
+ * @param {Object} params
+ * @param {string|{pattern:string, flags?:string}} [params.text] - Optional find by text content
+ * @param {number} [params.parent_levels] - Optional number of parent levels to include in the result (default: 0, meaning only the element itself)
+ */
+export const browser_find = async (params, stubber_context) => {
+  // Get the Chromium page
+  const page_result = await get_chromium_page(params, stubber_context);
+  if (!page_result.success) {
+    return page_result;
+  }
+
+  const page = page_result.payload;
+
+  if (!params?.text) {
+    return create_error_conceptual({ message: "Missing required parameter: text" });
+  }
+
+  try {
+    const text = typeof params.text === "string" ? params.text : new RegExp(params.text.pattern, params.text.flags);
+
+    const locators = await page.getByText(text).all();
+
+    if (!locators.length) {
+      return create_error_conceptual({ message: "Text not found on the page", details: { text: params.text } });
+    }
+
+    const results = [];
+    for (const locator of locators) {
+      let element = locator;
+      for (let i = 0; i < (params.parent_levels || 0); i++) {
+        element = await element.evaluateHandle((el) => el.parentElement);
+        if (!element) break;
+      }
+      const html_content = await element.evaluate((el) => el.outerHTML);
+      results.push({ html_content });
+    }
+
+    return create_success({ message: `Found ${results.length} element(s) matching the text`, payload: { results } });
+  } catch (error) {
+    return create_error_technical(error);
+  }
+};

package/app/commands/browser/browser_manage_sessions.js

@@ -21,7 +21,7 @@ export const browser_manage_sessions = async (params, stubber_context) => {
     return await clear_chromium_sessions(session_ids);
   } else if (operation === "delete_all") {
     const sessions_result = await list_chromium_sessions();
-    const all_session_ids = sessions_result.payload.sessions;
+    const all_session_ids = sessions_result.payload.session_ids;
     return await clear_chromium_sessions(all_session_ids);
   } else {
     return create_error_conceptual({ message: "Invalid operation. Must be 'list', 'delete', or 'delete_all'." });

package/app/commands/browser/browser_wait.js

@@ -0,0 +1,46 @@
+import { create_error_conceptual } from "#app/functions/create_error_conceptual.js";
+import { create_error_technical } from "#app/functions/create_error_technical.js";
+import { create_success } from "#root/app/functions/create_success.js";
+import { get_chromium_page } from "../../helpers/get_chromium_page.js";
+
+//  * @param {string} [params.text] - wait for specific text to appear
+//  * @param {string} [params.url] - wait for URL pattern
+//  * @param {string} [params.function] - wait for a custom function to return true, `window.ready == true` etc
+
+/**
+ *
+ * @param {Object} params
+ * @param {string} [params.locator] - wait for a specific element to appear using a locator
+ * @param {number} [params.ms] - wait for a specific amount of milliseconds
+ * @param {string} [params.load_state] - wait for specific load state (e.g. "load", "domcontentloaded", "networkidle")
+ */
+export const browser_wait = async (params, stubber_context) => {
+  // Get the Chromium page
+  const page_result = await get_chromium_page(params, stubber_context);
+  if (!page_result.success) {
+    return page_result;
+  }
+
+  const page = page_result.payload;
+
+  if (params.locator) {
+    await page.waitForSelector(params.locator);
+
+    return create_success({ message: `Element matching locator "${params.locator}" is now present on the page` });
+  } else if (params.ms) {
+    await page.waitForTimeout(params.ms);
+
+    return create_success({ message: `Waited for ${params.ms} milliseconds` });
+  } else if (params.load_state) {
+    await page.waitForLoadState(params.load_state);
+
+    return create_success({ message: `Page reached load state "${params.load_state}"` });
+  }
+
+  // return create_error_conceptual({ message: "Locator did not match any elements", details: { locator } });
+  // return create_error_technical(error);
+
+  return create_error_conceptual({
+    message: "No valid wait condition provided. Please specify a locator, ms, or load_state in the parameters.",
+  });
+};

package/app/commands/index.js

@@ -1,19 +1,22 @@
 import { browser_click } from "./browser/browser_click.js";
 import { browser_extract_data } from "./browser/browser_extract_data.js";
+import { browser_extract_html } from "./browser/browser_extract_html.js";
+import { browser_get_clipboard_text } from "./browser/browser_get_clipboard_text.js";
 import { browser_get_localstorage } from "./browser/browser_get_localstorage.js";
+import { browser_manage_sessions } from "./browser/browser_manage_sessions.js";
 import { browser_navigate } from "./browser/browser_navigate.js";
-import { browser_write_text } from "./browser/browser_write_text.js";
 import { browser_press_key } from "./browser/browser_press_key.js";
-import { browser_extract_html } from "./browser/browser_extract_html.js";
 import { browser_screenshot } from "./browser/browser_screenshot.js";
-import { browser_get_clipboard_text } from "./browser/browser_get_clipboard_text.js";
-import { browser_manage_sessions } from "./browser/browser_manage_sessions.js";
+import { browser_write_text } from "./browser/browser_write_text.js";
 import { cli_run } from "./cli/cli_run.js";
 
-import { upload_files } from "./file-server/upload_files.js";
 import { download_files } from "./file-server/download_files.js";
+import { upload_files } from "./file-server/upload_files.js";
 
 import { api_proxy } from "./api_proxy/api_proxy.js";
+import { browser_extract_markdown } from "./browser/browser_extract_markdown.js";
+import { browser_wait } from "./browser/browser_wait.js";
+import { browser_find } from "./browser/browser_find.js";
 
 const all_commands = {
   browser_click,
@@ -23,9 +26,12 @@ const all_commands = {
   browser_write_text,
   browser_press_key,
   browser_extract_html,
+  browser_extract_markdown,
   browser_screenshot,
   browser_get_clipboard_text,
   browser_manage_sessions,
+  browser_wait,
+  browser_find,
 
   cli_run,
 

package/app/commands/run_commands.js

@@ -5,18 +5,11 @@ import { all_commands } from "./index.js";
 import { create_success } from "#app/functions/create_success.js";
 import { create_error_technical } from "#app/functions/create_error_technical.js";
 import { create_error_conceptual } from "#app/functions/create_error_conceptual.js";
+import * as z from "zod";
 
 /**
- * @typedef {object} Command
- * @property {string} commandtype - The type of command to run.
- * @property {object} [params] - The parameters for the command.
- * @property {bool} [continue_on_error] - Whether to continue on error.
- * @property {number} [__order] - The order in which to run the command.
- * @property {string[]} [conditions] - Array of jsonata conditions to evaluate.
- */
-
-/**
- * @param {{[key: string]: Command}} commands
+ * @param {object} task
+ * @param {z.infer<typeof import("#app/controllers/virtual_worker_task.js").params_schema>} task.params
  * @param {object} _stubber - The context this task is being ran in.
  */
 export const run_commands = async (task, _stubber) => {
@@ -38,9 +31,14 @@ export const run_commands = async (task, _stubber) => {
   cloned_context.commands = payload.commands;
 
   let important_command_failed = false;
+  let command_index = 0;
   for (const [command_name, command] of command_entries) {
     console.log(`Starting command: ${command_name}`, command);
 
+    if (task.params.browser_session_id) {
+      command.params.session_id = task.params.browser_session_id;
+    }
+
     // Check if the command has conditions and evaluate them
     const conditions_met = await evaluate_command_conditions(command, cloned_context);
     if (!conditions_met) {
@@ -82,6 +80,10 @@ export const run_commands = async (task, _stubber) => {
       delete payload.commands[command_name].payload.attachments;
     }
 
+    // ensure a __order key is set on the payload.commands[command_name] for clearer debugging
+    payload.commands[command_name].__order = command_index;
+    command_index++;
+
     if (!payload.commands[command_name].success && !command.continue_on_error) {
       important_command_failed = true;
       break; // Stop execution if continue_on_error is falsy

package/app/controllers/virtual_worker_task.js

@@ -2,6 +2,7 @@ import { run_commands } from "#app/commands/run_commands.js";
 import { task_schema } from "#lib/interfaces/http/routers/stubber_task_schema.js";
 import * as z from "zod";
 import { worker_status } from "./virtual_worker_status.js";
+import { config } from "#root/config/main.js";
 
 const command_schema = z.looseObject({
   commandtype: z.string().min(1),
@@ -11,8 +12,9 @@ const command_schema = z.looseObject({
   conditions: z.array(z.string().or(z.boolean())).optional(),
 });
 
-const params_schema = z.looseObject({
+export const params_schema = z.looseObject({
   commands: z.record(z.string(), command_schema),
+  browser_session_id: z.string().min(1).optional(),
 });
 
 /**
@@ -27,5 +29,22 @@ export const virtual_worker_task = async (task) => {
 
   const task_result = await run_commands(task, stubber);
 
+  let vnc_url = `${config.vnc_origin}/vnc?worker_name=${encodeURIComponent(config.worker_name)}&orguuid=${
+    task._stubber.orguuid
+  }`;
+
+  if (config.api_key) {
+    vnc_url += `&api_key=${config.api_key}`;
+  }
+
+  const worker_name = config.worker_name;
+
+  task_result.details = {
+    worker_info: {
+      vnc_url: config.vnc_origin ? vnc_url : null,
+      worker_name,
+    },
+  };
+
   return task_result;
 };

package/app/helpers/get_chromium_page.js

@@ -22,6 +22,8 @@ export const get_chromium_page = async (params, stubber_context) => {
     return create_error_conceptual({ message: "session_id is required to get a Chromium page." });
   }
 
+  console.log("get_chromium_page called with session_id:", session_id);
+
   let slow_mo = params?.slow_mo || process.env.SLOW_MO || 0;
 
   slow_mo = Number(slow_mo);
@@ -40,6 +42,10 @@ export const get_chromium_page = async (params, stubber_context) => {
       // eslint-disable-next-line id-match
       slowMo: slow_mo,
     });
+    browser.on("disconnected", () => {
+      console.log("Chromium browser disconnected. Cleaning up browser instance.");
+      browser = null;
+    });
   }
 
   // Create a new context per stubref if not already created
@@ -52,6 +58,10 @@ export const get_chromium_page = async (params, stubber_context) => {
     contexts[session_id] = {
       context,
     };
+    context.on("close", () => {
+      console.log(`Chromium context for session_id=${session_id} closed. Cleaning up.`);
+      delete contexts[session_id];
+    });
   }
 
   const context = contexts[session_id].context;
@@ -71,27 +81,27 @@ export const list_chromium_sessions = () => {
   return create_success({
     message: "Successfully listed Chromium sessions.",
     payload: {
-      sessions: Object.keys(contexts),
+      session_ids: Object.keys(contexts),
     },
   });
 };
 
 export const clear_chromium_sessions = async (session_ids) => {
   try {
-    let cleared_sessions = [];
+    let cleared_session_ids = [];
     for (const session_id of session_ids) {
       const context_entry = contexts[session_id];
       if (context_entry) {
         await context_entry.context.close();
         delete contexts[session_id];
-        cleared_sessions.push(session_id);
+        cleared_session_ids.push(session_id);
       }
     }
     return create_success({
       message: "Successfully cleared specified Chromium sessions.",
       payload: {
-        cleared_sessions,
-        sessions: Object.keys(contexts),
+        cleared_session_ids,
+        session_ids: Object.keys(contexts),
       },
     });
   } catch (error) {

package/devel/tests.sh

@@ -0,0 +1,68 @@
+curl -X POST "http://localhost:3000/api/v1/task-gateway/virtual_worker_send_commands" \
+  -H "Content-Type: application/json" \
+  -H "stubber-virtual-worker-apikey: 123-456-789" \
+  -d '{
+    "task": {
+      "tasktype": "virtual_worker_send_commands",
+      "task_name": "virtual_worker_send_commands",
+      "params": {
+        "commands": {
+            "command_1": {
+                "commandtype": "browser_navigate",
+                "params": {
+                    "url": "https://fast.com"
+                }
+            },
+            "command_2": {
+                "commandtype": "browser_wait",
+                "params": {
+                   "ms": 2000
+                }
+            },
+            "command_3": {
+                "commandtype": "browser_extract_markdown",
+                "params": {
+                }
+            }
+        }
+      },
+      "_stubber": {
+        "orguuid": "c8cfd7f1-8015-43ff-8878-d22c136a2325",
+        "stubref": "my-stub-ref"
+      }
+    }
+  }'
+
+  curl -X POST "http://localhost:3000/api/v1/task-gateway/virtual_worker_send_commands" \
+  -H "Content-Type: application/json" \
+  -H "stubber-virtual-worker-apikey: 123-456-789" \
+  -d '{
+    "task": {
+      "tasktype": "virtual_worker_send_commands",
+      "task_name": "virtual_worker_send_commands",
+      "params": {
+        "commands": {
+            "command_1": {
+                "commandtype": "browser_navigate",
+                "params": {
+                    "url": "https://berkshirehathaway.com"
+                }
+            },
+            "command_2": {
+                "commandtype": "browser_find",
+                "params": {
+                   "text": {
+                      "pattern": "Warren.*Buffett",
+                      "flags": "i"
+                    },
+                   "parent_levels": 1
+                }
+            }
+        }
+      },
+      "_stubber": {
+        "orguuid": "c8cfd7f1-8015-43ff-8878-d22c136a2325",
+        "stubref": "my-stub-ref"
+      }
+    }
+  }'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stubber/virtual-worker",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Template to easily create a node app and keep development standards",
   "main": "app.js",
   "directories": {
@@ -38,6 +38,7 @@
     "lodash-es": "^4.17.21",
     "mime-types": "^3.0.1",
     "net": "^1.0.2",
+    "node-html-markdown": "^2.0.0",
     "playwright": "^1.53.0",
     "socket.io-client": "^4.8.1",
     "uuid": "^9.0.0",

package/app_config.js

@@ -1,6 +0,0 @@
-export const config = {
-  WORKER_CONNECT_URL: process.env.WORKER_CONNECT_URL,
-  WORKER_SIGNATURE: process.env.WORKER_SIGNATURE,
-  WORKER_WORKERUUID: process.env.WORKER_WORKERUUID,
-  WORKER_GROUPS: process.env.WORKER_GROUPS?.split(",") || [],
-};