@stubber/virtual-worker 1.0.2 → 1.0.3

package/.env_dev

@@ -1 +1,5 @@
-FILESERVER_URL="https://uploads.secure-link.services.dev.stubber.com/api/v1"
+FILESERVER_URL=https://uploads.secure-link.services.dev.stubber.com/api/v1
+API_KEY=123-456-789
+WORKER_NAME=worker-01
+VNC_ORIGIN=ws://localhost:3000
+NODE_ENV=development

package/app/commands/browser/browser_extract_html.js

@@ -0,0 +1,38 @@
+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 {Object} params
+ * @param {string} [params.locator] - Optional locator to extract HTML from a specific element
+ */
+export const browser_extract_html = async (params, stubber_context) => {
+  // Get the Chromium page
+  const page_result = await get_chromium_page(stubber_context.stubref);
+  if (!page_result.success) {
+    return page_result;
+  }
+
+  const page = page_result.payload;
+  let html_content = "";
+
+  try {
+    const { locator } = params || {};
+
+    if (locator) {
+      const target = page.locator(locator);
+      if (!(await target.count())) {
+        return create_error_conceptual({ message: "Locator did not match any elements", details: { locator } });
+      }
+      html_content = await target.evaluate((el) => el.outerHTML);
+    } else {
+      html_content = await page.content();
+    }
+  } catch (error) {
+    return create_error_technical(error);
+  }
+
+  return create_success({ message: `HTML content retrieved successfully`, payload: { html_content } });
+};

package/app/commands/browser/browser_screenshot.js

@@ -0,0 +1,59 @@
+import { get_chromium_page } from "#app/helpers/get_chromium_page.js";
+import { create_error_conceptual } from "#app/functions/create_error_conceptual.js";
+import { upload_files } from "../file-server/upload_files.js";
+import { create_success } from "#app/functions/create_success.js";
+import { create_error_technical } from "#app/functions/create_error_technical.js";
+
+/**
+ *
+ * @param {Object} params
+ * @param {import('playwright').PageScreenshotOptions} [params.screenshot_options] - Optional screenshot options
+ * @param {string} [params.locator] - Optional locator to screenshot a specific element
+ * @returns
+ */
+export const browser_screenshot = async ({ screenshot_options, locator }, stubber_context) => {
+  const page_result = await get_chromium_page(stubber_context.stubref);
+  if (!page_result.success) {
+    return page_result;
+  }
+  const page = page_result.payload;
+
+  if (!screenshot_options || typeof screenshot_options !== "object") {
+    screenshot_options = {};
+  }
+
+  try {
+    if (!screenshot_options.path) {
+      const tmp_path = `/tmp/screenshot_${Date.now()}.png`;
+      screenshot_options.path = tmp_path;
+    }
+
+    let target = page;
+
+    if (locator) {
+      target = page.locator(locator);
+      if (!(await target.count())) {
+        return create_error_conceptual({ message: "Locator did not match any elements", details: { locator } });
+      }
+    }
+
+    await target.screenshot(screenshot_options);
+
+    // upload the screenshot to the file server
+    const upload_result = await upload_files({ files: [screenshot_options.path] }, stubber_context);
+
+    if (!upload_result.success) {
+      return upload_result;
+    }
+
+    const uploaded_files = upload_result.payload.uploaded_files;
+    const file_info = uploaded_files.length > 0 ? uploaded_files[0] : null;
+
+    return create_success({
+      message: "Screenshot captured successfully",
+      payload: { screenshot: { path: screenshot_options.path, file_info } },
+    });
+  } catch (error) {
+    return create_error_technical(error);
+  }
+};

package/app/commands/index.js

@@ -4,6 +4,8 @@ import { browser_get_localstorage } from "./browser/browser_get_localstorage.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 { cli_run } from "./cli/cli_run.js";
 
 import { upload_files } from "./file-server/upload_files.js";
@@ -16,6 +18,8 @@ const all_commands = {
   browser_navigate,
   browser_write_text,
   browser_press_key,
+  browser_extract_html,
+  browser_screenshot,
 
   cli_run,
 

package/app/controllers/virtual_worker_list.js

@@ -0,0 +1,37 @@
+import { task_schema } from "#lib/interfaces/http/routers/stubber_task_schema.js";
+import { config } from "#root/config/main.js";
+import * as z from "zod";
+import { create_success } from "../functions/create_success.js";
+import { virtual_worker_status } from "./virtual_worker_status.js";
+
+// const params_schema = z.looseObject({});
+
+/**
+ * Lists all virtual workers available. Mostly these will just list themselves as the solo worker.
+ * However stubber-virtual-worker-k8s-router has the same implementation but lists all workers in the k8s cluster.
+ * @param {z.infer<typeof task_schema>} task
+ */
+export const virtual_worker_list = async (task) => {
+  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 task_result = create_success({
+    message: "Virtual worker list retrieved successfully",
+    payload: {
+      workers: [
+        {
+          worker_name: config.worker_name,
+          status: await virtual_worker_status({}),
+          vnc_url,
+        },
+      ],
+    },
+  });
+
+  return task_result;
+};

package/app/helpers/get_chromium_page.js

@@ -11,7 +11,6 @@ let browser;
  * last_used: number
 }>} */
 const contexts = {};
-const CONTEXT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 
 /**
  * @param {string} stubref
@@ -22,19 +21,6 @@ export const get_chromium_page = async (stubref) => {
     return create_error_conceptual({ message: "stubref is required to get a Chromium page." });
   }
 
-  // Cleanup unused contexts
-  const now = Date.now();
-  for (const [key, value] of Object.entries(contexts)) {
-    if (value.last_used && now - value.last_used > CONTEXT_TIMEOUT_MS) {
-      try {
-        await value.context.close();
-      } catch (e) {
-        // ignore errors during cleanup
-      }
-      delete contexts[key];
-    }
-  }
-
   // Launch the browser once and reuse it
   if (!browser) {
     browser = await chromium.launch({
@@ -52,10 +38,7 @@ export const get_chromium_page = async (stubref) => {
     });
     contexts[stubref] = {
       context,
-      last_used: now,
     };
-  } else {
-    contexts[stubref].last_used = now;
   }
 
   const context = contexts[stubref].context;

package/config/main.js

@@ -1,3 +1,6 @@
 export const config = {
   fileserver_url: process.env.FILESERVER_URL || "https://uploads.secure-link.services.stubber.com/api/v1",
+  api_key: process.env.API_KEY,
+  worker_name: process.env.WORKER_NAME || "unnamed_worker",
+  vnc_origin: process.env.VNC_ORIGIN,
 };

package/lib/interfaces/http/index.js

@@ -1,11 +1,40 @@
 import body_parser from "body-parser";
 import express from "express";
+// eslint-disable-next-line id-match
+import { WebSocketServer } from "ws";
+import net from "net";
 import task_gateway_router from "./routers/task_gateway.js";
-import { virtual_worker_status } from "#root/app/controllers/virtual_worker_status.js";
+import { virtual_worker_status } from "#app/controllers/virtual_worker_status.js";
+import { config } from "#root/config/main.js";
+import { create_error_conceptual } from "#root/app/functions/create_error_conceptual.js";
 
 export const start_http_server = () => {
   const app = express();
-  app.use(body_parser.json());
+  app.use(
+    body_parser.json({
+      limit: "10mb",
+    })
+  );
+
+  // add APIKEY middleware
+  if (config.api_key) {
+    app.use((req, res, next) => {
+      const incoming_apikey = req.headers["stubber-virtual-worker-apikey"];
+
+      if (incoming_apikey !== config.api_key) {
+        return res.status(403).json(
+          create_error_conceptual({
+            message: "Invalid API Key",
+            details: {
+              provided_apikey: incoming_apikey,
+            },
+          })
+        );
+      }
+
+      next();
+    });
+  }
 
   // ROUTERS
   app.use("/api/v1/task-gateway", task_gateway_router);
@@ -17,7 +46,67 @@ export const start_http_server = () => {
   });
 
   const PORT = process.env.HTTP_PORT || 3000;
-  app.listen(PORT, () => {
+  const server = app.listen(PORT, () => {
     console.log(`HTTP server is running on port ${PORT}`);
   });
+
+  // WebSocket server for VNC proxy
+  const wss = new WebSocketServer({ server, path: "/vnc" });
+  const VNC_HOST = process.env.VNC_HOST || "localhost";
+  const VNC_PORT = process.env.VNC_PORT || 5900;
+
+  wss.on("connection", (ws, req) => {
+    console.log("WebSocket client connected to VNC proxy");
+
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const incoming_apikey = url.searchParams.get("api_key");
+
+    if (incoming_apikey !== config.api_key) {
+      console.log("Invalid VNC API key, closing connection");
+      ws.close();
+      return;
+    }
+
+    // Create TCP connection to VNC server
+    const vnc_socket = net.createConnection(VNC_PORT, VNC_HOST, () => {
+      console.log(`Connected to VNC server at ${VNC_HOST}:${VNC_PORT}`);
+    });
+
+    // Proxy data from VNC server to WebSocket client
+    vnc_socket.on("data", (data) => {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(data);
+      }
+    });
+
+    // Proxy data from WebSocket client to VNC server
+    ws.on("message", (data) => {
+      vnc_socket.write(data);
+    });
+
+    // Handle WebSocket close
+    ws.on("close", () => {
+      console.log("WebSocket client disconnected");
+      vnc_socket.end();
+    });
+
+    // Handle VNC socket close
+    vnc_socket.on("close", () => {
+      console.log("VNC connection closed");
+      ws.close();
+    });
+
+    // Handle errors
+    ws.on("error", (err) => {
+      console.error("WebSocket error:", err);
+      vnc_socket.end();
+    });
+
+    vnc_socket.on("error", (err) => {
+      console.error("VNC socket error:", err);
+      ws.close();
+    });
+  });
+
+  console.log(`WebSocket VNC proxy listening on ws://localhost:${PORT}/vnc`);
 };

package/lib/interfaces/http/routers/stubber_task_schema.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 
 export const stubber_schema = z.looseObject({
   orguuid: z.uuid(),
+  stubref: z.string().min(1),
 });
 
 export const task_schema = z.looseObject({

package/lib/interfaces/http/routers/task_gateway.js

@@ -5,11 +5,12 @@ import { create_error_technical } from "#app/functions/create_error_technical.js
 import { Router } from "express";
 import * as z from "zod";
 import { task_payload_schema } from "./stubber_task_schema.js";
-import { virtual_worker_status } from "#root/app/controllers/virtual_worker_status.js";
+import { virtual_worker_status } from "#app/controllers/virtual_worker_status.js";
+import { virtual_worker_list } from "#app/controllers/virtual_worker_list.js";
 
 const router = Router();
 
-router.post("/virtual_worker_task", async (req, res) => {
+router.post(["/virtual_worker_task", "/virtual_worker_send_commands", "/send_commands"], async (req, res) => {
   try {
     const payload = task_payload_schema.parse(req.body);
     const task = payload.task;
@@ -24,26 +25,46 @@ router.post("/virtual_worker_task", async (req, res) => {
       res.status(400).json(result);
     }
   } catch (error) {
-    // handle zod validation errors
-    if (error instanceof z.ZodError) {
-      // console.log("Zod validation error:", error);
-      res.status(400).json(
-        create_error_conceptual({
-          message: "Validation error",
-          details: {
-            errors: JSON.parse(error.message),
-          },
-        })
-      );
-    } else {
-      res.status(500).json(create_error_technical(error));
-    }
+    handle_zod_error(error, res);
   }
 });
 
-router.post("/virtual_worker_status", async (req, res) => {
-  const result = await virtual_worker_status({});
-  res.status(200).json(result);
+router.post("/get_status", async (req, res) => {
+  try {
+    const payload = task_payload_schema.parse(req.body);
+    const task = payload.task;
+    const result = await virtual_worker_status(task);
+    res.status(200).json(result);
+  } catch (error) {
+    handle_zod_error(error, res);
+  }
 });
 
+router.post("/list_workers", async (req, res) => {
+  try {
+    const payload = task_payload_schema.parse(req.body);
+    const task = payload.task;
+    const result = await virtual_worker_list(task);
+    res.status(200).json(result);
+  } catch (error) {
+    handle_zod_error(error, res);
+  }
+});
+
+const handle_zod_error = (error, res) => {
+  if (error instanceof z.ZodError) {
+    res.status(400).json(
+      create_error_conceptual({
+        message: "Validation error",
+        details: {
+          errors: JSON.parse(error.message),
+        },
+      })
+    );
+    return;
+  }
+
+  res.status(500).json(create_error_technical(error));
+};
+
 export default router;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stubber/virtual-worker",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Template to easily create a node app and keep development standards",
   "main": "app.js",
   "directories": {
@@ -41,6 +41,7 @@
     "playwright": "^1.53.0",
     "socket.io-client": "^4.8.1",
     "uuid": "^9.0.0",
+    "ws": "^8.18.3",
     "zod": "^4.1.12"
   },
   "devDependencies": {

package/.env_devmaster

@@ -1 +0,0 @@
-FILESERVER_URL="https://uploads.secure-link.services.dev.stubber.com/api/v1"