@stubber/virtual-worker 1.0.1 → 1.0.3

package/.env_dev

@@ -1,14 +1,5 @@
-# when running inside docker and connecting to tag running on host machine
-# WORKER_CONNECT_URL=http://172.17.0.1:7450/orgs/7cf3b2dc-5a49-51dd-8b4d-812a8ba6f233
-# when running using npm run dev and connecting to tag running on host machine
-# WORKER_CONNECT_URL=http://localhost:7450/orgs/7cf3b2dc-5a49-51dd-8b4d-812a8ba6f233
-# when used in docker or with npm run, connect to the devmaster tag
-WORKER_CONNECT_URL="https://virtual-workers.dev.stubber.com/orgs/7cf3b2dc-5a49-51dd-8b4d-812a8ba6f233"
-
-WORKER_SIGNATURE=069c293dc0d71dd42b32b122da62b2deae08c12c67a85224d14a7dd8c4907f21
-
-WORKER_WORKERUUID=b0bf29a8-5ebb-4b79-b464-9d35686ebc7d
-
-WORKER_GROUPS=insurance-worker,b0bf29a8-5ebb-4b79-b464-9d35686ebc7d
-
-NODE_ENV=development
+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/file-server/download_files.js

@@ -5,10 +5,20 @@ import { create_success } from "#app/functions/create_success.js";
 import { writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { config } from "#root/config/main.js";
+
+/**
+ * @typedef FileInfoObject
+ * @property {string} fileuuid - The UUID of the file
+ * @property {string} filename - The name of the file
+ * @property {string} originalname - The original name of the file
+ * @property {string} contentType - The content type of the file
+ * @property {string} f_id - The file ID added by form fields
+ */
 
 /**
  * @typedef DownloadFilesParams
- * @property {Array<string|{fileuuid:string}>} files - The files to download
+ * @property {Array<string|FileInfoObject>} files - The files to download
  */
 
 /**
@@ -23,11 +33,11 @@ import { join } from "node:path";
  * @param {DownloadFilesParams} params
  */
 export const download_files = async (params, _stubber) => {
-  // todo: how will fileserver work now that we dont have sockets
-  const socket = _stubber?.stubber_context.socket;
-  if (!socket) {
-    return create_error_conceptual({ message: "Socket not available", details: {} });
+  const fileserver_url = config?.fileserver_url;
+  if (!fileserver_url) {
+    return create_error_conceptual({ message: "Fileserver URL not configured", details: {} });
   }
+  console.log("Fileserver URL:", fileserver_url);
 
   const { files } = params || {};
   if (!files) {
@@ -37,44 +47,50 @@ export const download_files = async (params, _stubber) => {
     return create_error_conceptual({ message: "Files must be a non-empty array", details: { files } });
   }
 
-  const uuids = [];
+  /**
+   * @type {Array<{fileuuid:string, filename:string}>}
+   */
+  const files_to_download = [];
   for (const file of files) {
     if (typeof file === "string") {
-      uuids.push(file);
+      files_to_download.push({ fileuuid: file, filename: file });
     } else if (file && typeof file === "object" && typeof file.fileuuid === "string") {
-      uuids.push(file.fileuuid);
+      files_to_download.push({
+        fileuuid: file.fileuuid,
+        filename: file.filename || file.originalname || file.fileuuid,
+      });
     } else {
       return create_error_conceptual({ message: "Invalid file entry in files array", details: { entry: file } });
     }
   }
 
-  return new Promise((resolve) => {
-    const downloaded_files = [];
+  const downloaded_files = [];
 
-    socket.emit("download_files", uuids, async (response) => {
-      if (response.success) {
-        /** @type {ResponseFile[]} */
-        const files = response.payload;
+  for (const { fileuuid, filename } of files_to_download) {
+    const file_url = `${fileserver_url}/file/uuid/${encodeURIComponent(fileuuid)}`;
 
-        for (const file of files) {
-          if (file.status == 200) {
-            // todo: support passing download location in params
-            const tmp_dir = tmpdir();
-            const file_path = join(tmp_dir, file.fileuuid);
+    try {
+      const response = await fetch(file_url);
 
-            await writeFile(file_path, file.data);
+      if (!response.ok) {
+        console.log("Error downloading file:", { fileuuid, status: response.status, status_text: response.statusText });
+        continue;
+      }
 
-            downloaded_files.push(file_path);
-          } else {
-            console.log("Error downloading file:", file);
-          }
-        }
+      const array_buffer = await response.arrayBuffer();
+      const data = Buffer.from(array_buffer);
 
-        resolve(create_success({ message: "Files downloaded successfully", payload: { downloaded_files } }));
-      } else {
-        console.log("Error downloading files:", response.error);
-        resolve(create_error_technical(response.error));
-      }
-    });
-  });
+      // todo: support passing download location in params
+      const tmp_dir = tmpdir();
+      const file_path = join(tmp_dir, filename);
+
+      await writeFile(file_path, data);
+
+      downloaded_files.push(file_path);
+    } catch (error) {
+      console.log("Error downloading file:", { fileuuid, error });
+    }
+  }
+
+  return create_success({ message: "Files downloaded successfully", payload: { downloaded_files } });
 };

package/app/commands/file-server/upload_files.js

@@ -1,8 +1,14 @@
 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 { config } from "#root/config/main.js";
 // eslint-disable-next-line id-match
 import { readFile } from "node:fs/promises";
+// eslint-disable-next-line id-match
+import { Blob } from "buffer";
+import mime from "mime-types";
+// eslint-disable-next-line id-match
+import { fileTypeFromBuffer } from "file-type";
 
 /**
  * Upload files to the server
@@ -10,10 +16,15 @@ import { readFile } from "node:fs/promises";
  * @param {Array<string>} params.files - The path to files to upload
  */
 export const upload_files = async (params, _stubber) => {
-  /** @type {import("socket.io-client").Socket} */
-  const socket = _stubber?.stubber_context.socket;
-  if (!socket) {
-    return create_error_conceptual({ message: "Socket not available", details: {} });
+  const fileserver_url = config?.fileserver_url;
+  if (!fileserver_url) {
+    return create_error_conceptual({ message: "Fileserver URL not configured", details: {} });
+  }
+  console.log("Fileserver URL:", fileserver_url);
+
+  const orguuid = _stubber?.orguuid;
+  if (!orguuid) {
+    return create_error_conceptual({ message: "orguuid not available", details: {} });
   }
 
   const { files } = params || {};
@@ -24,34 +35,74 @@ export const upload_files = async (params, _stubber) => {
     });
   }
 
-  const uploaded_files = [];
+  const form_data = new FormData();
+  const endpoint = `${fileserver_url}/upload?orguuid=${encodeURIComponent(orguuid)}`;
 
   for (const filepath of files) {
     const filename = filepath.split("/").pop();
-    const file = await readFile(filepath); // Buffer
 
-    // Wrap socket.emit in a promise so we can await it
-    const file_info = await emit_upload(socket, { filepath, filename }, file);
+    if (!filename) {
+      return create_error_conceptual({
+        message: "Unable to determine filename from path",
+        details: { filepath },
+      });
+    }
+
+    try {
+      let mimetype = mime.lookup(filename) || "application/octet-stream";
 
-    if (file_info) {
-      uploaded_files.push(file_info);
+      const file_buffer = await readFile(filepath);
+
+      const type = await fileTypeFromBuffer(file_buffer);
+      if (type?.mime) {
+        mimetype = type.mime; // trust buffer over extension
+      }
+
+      const blob = new Blob([file_buffer], { type: mimetype });
+      form_data.append("file", blob, filename);
+    } catch (error) {
+      return create_error_technical(error);
     }
   }
 
-  return create_success({ message: "Files uploaded successfully", payload: { uploaded_files } });
-};
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      body: form_data,
+    });
 
-/**
- * Wraps a socket.emit call in a Promise
- */
-function emit_upload(socket, metadata, buffer) {
-  return new Promise((resolve, reject) => {
-    socket.emit("upload_file", metadata, buffer, (response) => {
-      if (!response.success) {
-        reject(new Error(response));
-      } else {
-        resolve(response.payload);
+    if (!response.ok) {
+      let error_payload = null;
+      try {
+        error_payload = await response.json();
+      } catch (_) {
+        error_payload = { raw_error: await response.text() };
       }
+
+      return create_error_conceptual({
+        message: "Failed to upload files",
+        details: { status: response.status, error_payload },
+      });
+    }
+
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch (error) {
+      return create_error_technical(error);
+    }
+
+    if (payload?.data?.uploaded_files) {
+      payload = {
+        uploaded_files: payload.data.uploaded_files,
+      };
+    }
+
+    return create_success({
+      message: "Files uploaded successfully",
+      payload,
     });
-  });
-}
+  } 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/controllers/virtual_worker_task.js

@@ -3,7 +3,7 @@ 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";
 
-const command_schema = z.object({
+const command_schema = z.looseObject({
   commandtype: z.string().min(1),
   params: z.record(z.string(), z.any()).optional(),
   continue_on_error: z.boolean().optional(),
@@ -11,11 +11,8 @@ const command_schema = z.object({
   conditions: z.array(z.string()).optional(),
 });
 
-const params_schema = z.object({
+const params_schema = z.looseObject({
   commands: z.record(z.string(), command_schema),
-  worker: z.object({
-    group: z.string().min(1),
-  }),
 });
 
 /**

package/app/functions/create_error_technical.js

@@ -11,7 +11,7 @@ export const create_error_technical = (error) => {
       details: {
         name: error.name,
         // stack up to the second \n newline
-        stack: error.stack.split("\n").slice(0, 2).join("\n"),
+        stack: error.stack?.split("\n").slice(0, 2).join("\n"),
       },
     },
   };

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

@@ -0,0 +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

@@ -1,16 +1,17 @@
 import * as z from "zod";
 
-export const stubber_schema = z.object({
+export const stubber_schema = z.looseObject({
   orguuid: z.uuid(),
+  stubref: z.string().min(1),
 });
 
-export const task_schema = z.object({
+export const task_schema = z.looseObject({
   tasktype: z.string().min(1),
   task_name: z.string().min(1),
   params: z.any(),
   _stubber: stubber_schema,
 });
 
-export const task_payload_schema = z.object({
+export const task_payload_schema = z.looseObject({
   task: task_schema,
 });

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.1",
+  "version": "1.0.3",
   "description": "Template to easily create a node app and keep development standards",
   "main": "app.js",
   "directories": {
@@ -33,12 +33,15 @@
     "body-parser": "^1.20.3",
     "dotenv": "^16.0.3",
     "express": "^4.18.2",
+    "file-type": "^21.0.0",
     "jsonata": "^2.1.0",
     "lodash-es": "^4.17.21",
+    "mime-types": "^3.0.1",
     "net": "^1.0.2",
     "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,7 +0,0 @@
-WORKER_CONNECT_URL="https://virtual-workers.dev.stubber.com/orgs/7cf3b2dc-5a49-51dd-8b4d-812a8ba6f233"
-
-WORKER_SIGNATURE=069c293dc0d71dd42b32b122da62b2deae08c12c67a85224d14a7dd8c4907f21
-
-WORKER_WORKERUUID=b0bf29a8-5ebb-4b79-b464-9d35686ebc7d
-
-WORKER_GROUPS=insurance-worker,b0bf29a8-5ebb-4b79-b464-9d35686ebc7d