@stubber/virtual-worker 1.5.5 → 1.6.0

package/app/commands/browser/browser_execute.js

@@ -0,0 +1,311 @@
+/* eslint-disable id-match */
+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 "#app/functions/create_success.js";
+import { get_chromium_page } from "../../helpers/get_chromium_page.js";
+import * as playwright from "playwright";
+
+const DEFAULT_TIMEOUT_MS = 30000;
+const MAX_SERIALIZATION_DEPTH = 6;
+const MAX_SERIALIZATION_KEYS = 100;
+const async_function_constructor = async function () {}.constructor;
+
+/**
+ * Runs user-provided Playwright code against the current Chromium page.
+ * The code is executed as the body of an async function, so `await` and `return`
+ * can be used directly.
+ *
+ * Exposed variables inside the execution context:
+ * - `page`: current Playwright page
+ * - `context`: the page's BrowserContext
+ * - `browser`: the underlying browser instance, if available
+ * - `playwright`: Playwright module namespace
+ * - `args`: arbitrary user-provided arguments
+ * - `params`: original params object
+ * - `stubber_context`: task stubber context
+ *
+ * This runs in-process by design. Isolation is expected to come from the
+ * worker container, not from a JavaScript sandbox.
+ * @param {Object} params
+ * @param {string} params.code - The Playwright code to execute
+ * @param {Object} [params.args] - Optional arguments to pass to the code
+ * @param {number} [params.timeout_ms] - Optional timeout for code execution in milliseconds (default: 30000)
+ *
+ *
+ */
+export const browser_execute = async (params, stubber_context) => {
+  if (!params || typeof params.code !== "string" || !params.code.trim()) {
+    return create_error_conceptual({ message: "Missing required parameter: code" });
+  }
+
+  const page_result = await get_chromium_page(params, stubber_context);
+  if (!page_result.success) {
+    return page_result;
+  }
+
+  const page = page_result.payload;
+  const context = page.context();
+  const browser = context.browser();
+  const timeout_ms = normalize_timeout(params.timeout_ms);
+
+  if (timeout_ms === null) {
+    return create_error_conceptual({
+      message: "timeout_ms must be a non-negative number",
+      details: { timeout_ms: params.timeout_ms },
+    });
+  }
+
+  try {
+    const logs = [];
+    const execution_console = create_execution_console(logs);
+    const execution = run_user_code(params.code, {
+      page,
+      context,
+      browser,
+      playwright,
+      params,
+      args: params.args || {},
+      console: execution_console,
+      setTimeout,
+      clearTimeout,
+      setInterval,
+      clearInterval,
+      URL,
+      URLSearchParams,
+      TextEncoder,
+      TextDecoder,
+      AbortController,
+      AbortSignal,
+    });
+
+    const raw_result = await with_timeout(Promise.resolve(execution), timeout_ms);
+    const result = serialize_for_payload(raw_result);
+
+    return create_success({
+      message: "Playwright code executed successfully",
+      payload: {
+        result,
+        logs,
+      },
+    });
+  } catch (error) {
+    return create_error_technical(error);
+  }
+};
+
+/**
+ * @param {string} code
+ * @param {object} execution_scope
+ */
+const run_user_code = (code, execution_scope) => {
+  const parameter_names = Object.keys(execution_scope);
+  const parameter_values = Object.values(execution_scope);
+  const execute = new async_function_constructor(...parameter_names, code);
+
+  return execute(...parameter_values);
+};
+
+/**
+ * @param {unknown} timeout_ms
+ * @returns {number|null}
+ */
+const normalize_timeout = (timeout_ms) => {
+  if (!timeout_ms) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+
+  const normalized = Number(timeout_ms);
+
+  if (Number.isNaN(normalized) || normalized < 0) {
+    return null;
+  }
+
+  return normalized;
+};
+
+/**
+ * @param {Promise<unknown>} promise
+ * @param {number} timeout_ms
+ */
+const with_timeout = async (promise, timeout_ms) => {
+  if (timeout_ms === 0) {
+    return await promise;
+  }
+
+  let timeout_id;
+
+  const timeout_promise = new Promise((_, reject) => {
+    timeout_id = setTimeout(() => {
+      reject(new Error(`Playwright code execution timed out after ${timeout_ms}ms`));
+    }, timeout_ms);
+  });
+
+  try {
+    return await Promise.race([promise, timeout_promise]);
+  } finally {
+    clearTimeout(timeout_id);
+  }
+};
+
+/**
+ * @param {Array<{ level: string, args: unknown[] }>} logs
+ */
+const create_execution_console = (logs) => {
+  return {
+    debug: (...args) => log_execution("debug", args, logs),
+    info: (...args) => log_execution("info", args, logs),
+    log: (...args) => log_execution("log", args, logs),
+    warn: (...args) => log_execution("warn", args, logs),
+    error: (...args) => log_execution("error", args, logs),
+  };
+};
+
+/**
+ * @param {string} level
+ * @param {unknown[]} args
+ * @param {Array<{ level: string, args: unknown[] }>} logs
+ */
+const log_execution = (level, args, logs) => {
+  const serialized_args = args.map((arg) => serialize_for_payload(arg));
+  logs.push({ level, args: serialized_args });
+
+  const logger = console[level] || console.log;
+  logger("[browser_execute]", ...serialized_args);
+};
+
+/**
+ * @param {unknown} value
+ * @param {WeakSet<object>} [seen]
+ * @param {number} [depth]
+ * @returns {unknown}
+ */
+const serialize_for_payload = (value, seen = new WeakSet(), depth = 0) => {
+  if (value === null || value === undefined) {
+    return value ?? null;
+  }
+
+  if (depth >= MAX_SERIALIZATION_DEPTH) {
+    return `[MaxDepth:${get_constructor_name(value)}]`;
+  }
+
+  const value_type = typeof value;
+
+  if (value_type === "string" || value_type === "number" || value_type === "boolean") {
+    return value;
+  }
+
+  if (value_type === "bigint") {
+    return value.toString();
+  }
+
+  if (value_type === "function") {
+    return `[Function:${value.name || "anonymous"}]`;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serialize_for_payload(item, seen, depth + 1));
+  }
+
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack?.split("\n").slice(0, 2).join("\n"),
+    };
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (value_type === "object") {
+    if (seen.has(value)) {
+      return `[Circular:${get_constructor_name(value)}]`;
+    }
+
+    seen.add(value);
+
+    const playwright_summary = summarize_playwright_object(value);
+    if (playwright_summary) {
+      return playwright_summary;
+    }
+
+    const result = {};
+    const entries = Object.entries(value).slice(0, MAX_SERIALIZATION_KEYS);
+    for (const [key, entry_value] of entries) {
+      result[key] = serialize_for_payload(entry_value, seen, depth + 1);
+    }
+
+    return result;
+  }
+
+  return String(value);
+};
+
+/**
+ * @param {unknown} value
+ */
+const get_constructor_name = (value) => {
+  return value && typeof value === "object" && value.constructor?.name ? value.constructor.name : typeof value;
+};
+
+/**
+ * @param {unknown} value
+ * @returns {object|null}
+ */
+const summarize_playwright_object = (value) => {
+  const constructor_name = get_constructor_name(value);
+
+  if (constructor_name === "Page") {
+    return {
+      type: "Page",
+      url: safely_call(value, "url"),
+    };
+  }
+
+  if (constructor_name === "BrowserContext") {
+    const pages = safely_call(value, "pages");
+
+    return {
+      type: "BrowserContext",
+      page_count: Array.isArray(pages) ? pages.length : null,
+    };
+  }
+
+  if (constructor_name === "Browser") {
+    return {
+      type: "Browser",
+      is_connected: safely_call(value, "isConnected"),
+    };
+  }
+
+  if (constructor_name === "Locator") {
+    return {
+      type: "Locator",
+    };
+  }
+
+  if (constructor_name === "ElementHandle") {
+    return {
+      type: "ElementHandle",
+    };
+  }
+
+  return null;
+};
+
+/**
+ * @param {unknown} value
+ * @param {string} method_name
+ */
+const safely_call = (value, method_name) => {
+  try {
+    if (value && typeof value[method_name] === "function") {
+      return value[method_name]();
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+};

package/app/commands/index.js

@@ -17,6 +17,7 @@ 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";
+import { browser_execute } from "./browser/browser_execute.js";
 
 const all_commands = {
   browser_click,
@@ -32,6 +33,7 @@ const all_commands = {
   browser_manage_sessions,
   browser_wait,
   browser_find,
+  browser_execute,
 
   cli_run,
 

package/devel/browser_execute.http

@@ -0,0 +1,70 @@
+@baseUrl = http://localhost:3000
+@apiKey = 123-456-789
+@orguuid = c8cfd7f1-8015-43ff-8878-d22c136a2325
+@stubref = my-stub-ref
+
+POST {{baseUrl}}/api/v1/task-gateway/virtual_worker_send_commands
+Content-Type: application/json
+stubber-virtual-worker-apikey: {{apiKey}}
+
+{
+  "task": {
+    "tasktype": "virtual_worker_send_commands",
+    "task_name": "virtual_worker_send_commands",
+    "params": {
+      "commands": {
+        "command_1": {
+          "commandtype": "browser_navigate",
+          "params": {
+            "url": "https://en.wikipedia.org/wiki/Main_Page"
+          }
+        },
+        "command_2": {
+          "commandtype": "browser_execute",
+          "params": {
+            "args": {
+              "selector": "h1"
+            },
+            "code": "const title = await page.title();\nconst headings = await page.locator(args.selector).allInnerTexts();\nconsole.log({ title, headings });\nreturn { title, headings, url: page.url() };"
+          }
+        }
+      }
+    },
+    "_stubber": {
+      "orguuid": "{{orguuid}}",
+      "stubref": "{{stubref}}"
+    }
+  }
+}
+
+###
+
+# Run eval on the current page context.
+# Assumes the virtual worker already has an active browser page for this stub.
+POST {{baseUrl}}/api/v1/task-gateway/virtual_worker_send_commands
+Content-Type: application/json
+stubber-virtual-worker-apikey: {{apiKey}}
+
+{
+  "task": {
+    "tasktype": "virtual_worker_send_commands",
+    "task_name": "virtual_worker_send_commands",
+    "params": {
+      "commands": {
+        "command_1": {
+          "commandtype": "browser_execute",
+          "params": {
+            "args": {
+              "expression": "document.title"
+            },
+            "code": "const result = await page.evaluate((expression) => eval(expression), args.expression);\nreturn { expression: args.expression, result, url: page.url() };"
+          }
+        }
+      }
+    },
+    "_stubber": {
+      "orguuid": "{{orguuid}}",
+      "stubref": "{{stubref}}"
+    }
+  }
+}

package/devel/browser_extract_markdown.http

@@ -0,0 +1,39 @@
+@baseUrl = http://localhost:3000
+@apiKey = 123-456-789
+@orguuid = c8cfd7f1-8015-43ff-8878-d22c136a2325
+@stubref = my-stub-ref
+
+POST {{baseUrl}}/api/v1/task-gateway/virtual_worker_send_commands
+Content-Type: application/json
+stubber-virtual-worker-apikey: {{apiKey}}
+
+{
+  "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": "{{orguuid}}",
+      "stubref": "{{stubref}}"
+    }
+  }
+}

package/devel/browser_find.http

@@ -0,0 +1,39 @@
+@baseUrl = http://localhost:3000
+@apiKey = 123-456-789
+@orguuid = c8cfd7f1-8015-43ff-8878-d22c136a2325
+@stubref = my-stub-ref
+
+POST {{baseUrl}}/api/v1/task-gateway/virtual_worker_send_commands
+Content-Type: application/json
+stubber-virtual-worker-apikey: {{apiKey}}
+
+{
+  "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": "{{orguuid}}",
+      "stubref": "{{stubref}}"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stubber/virtual-worker",
-  "version": "1.5.5",
+  "version": "1.6.0",
   "description": "Template to easily create a node app and keep development standards",
   "main": "app.js",
   "directories": {

package/devel/tests.sh

@@ -1,68 +0,0 @@
-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"
-      }
-    }
-  }'