testeranto 0.200.0 → 0.202.0

package/src/PM/main.ts

@@ -3,2225 +3,847 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-import { ChildProcess, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import ansiColors from "ansi-colors";
 import net from "net";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
-import fs, { watch } from "fs";
-import path from "path";
-import puppeteer, { ConsoleMessage } from "puppeteer-core";
+import fs from "fs";
+import { ConsoleMessage } from "puppeteer-core";
 import ansiC from "ansi-colors";
-import crypto from "node:crypto";
-import { WebSocketServer } from "ws";
-import http from "http";
-import url from "url";
-import mime from "mime-types";
-
-import {
-  IFinalResults,
-  IRunnables,
-  ITTestResourceConfiguration,
-} from "../lib/index.js";
-import { getRunnables } from "../utils";
-import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-import { Sidecar } from "../lib/Sidecar.js";
-import { Queue } from "../utils/queue.js";
 
-import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+import { IFinalResults, ITTestResourceConfiguration } from "../lib/index.js";
+import { webEvaluator } from "../utils";
+import { Queue } from "../utils/queue.js";
 
-type IOutputs = Record<
-  string,
-  {
-    entryPoint: string;
-    inputs: Record<string, string>;
-  }
->;
+import { createLogStreams, statusMessagePretty } from "./utils.js";
+import { PM_WithProcesses } from "./PM_WithProcesses.js";
 
-const changes: Record<string, string> = {};
-const fileHashes = {};
 const files: Record<string, Set<string>> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
-type LogStreams = {
-  closeAll: () => void;
-  writeExitCode: (code: number, error?: Error) => void;
-  stdout?: fs.WriteStream;
-  stderr?: fs.WriteStream;
-  info?: fs.WriteStream;
-  warn?: fs.WriteStream;
-  error?: fs.WriteStream;
-  debug?: fs.WriteStream;
-  exit: fs.WriteStream;
-};
-
-function runtimeLogs(
-  runtime: IRunTime,
-  reportDest: string
-): Record<string, fs.WriteStream> {
-  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
-
-  try {
-    if (!fs.existsSync(safeDest)) {
-      fs.mkdirSync(safeDest, { recursive: true });
-    }
-
-    if (runtime === "node") {
-      return {
-        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
-        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`),
-      };
-    } else if (runtime === "web") {
-      return {
-        info: fs.createWriteStream(`${safeDest}/info.log`),
-        warn: fs.createWriteStream(`${safeDest}/warn.log`),
-        error: fs.createWriteStream(`${safeDest}/error.log`),
-        debug: fs.createWriteStream(`${safeDest}/debug.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`),
-      };
-    } else if (runtime === "pure") {
-      return {
-        exit: fs.createWriteStream(`${safeDest}/exit.log`),
-      };
-    } else if (runtime === "pitono") {
-      return {
-        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
-        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`),
-      };
-    } else {
-      throw `unknown runtime: ${runtime}`;
-    }
-  } catch (e) {
-    console.error(`Failed to create log streams in ${safeDest}:`, e);
-    throw e;
-  }
-}
-
-function createLogStreams(reportDest: string, runtime: IRunTime): LogStreams {
-  // Create directory if it doesn't exist
-  if (!fs.existsSync(reportDest)) {
-    fs.mkdirSync(reportDest, { recursive: true });
-  }
-
-  const streams = runtimeLogs(runtime, reportDest);
-
-  // const streams = {
-  //   exit: fs.createWriteStream(`${reportDest}/exit.log`),
-  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
-
-  try {
-    if (!fs.existsSync(safeDest)) {
-      fs.mkdirSync(safeDest, { recursive: true });
-    }
-
-    const streams = runtimeLogs(runtime, safeDest);
-    // const streams = {
-    //   exit: fs.createWriteStream(`${safeDest}/exit.log`),
-    //   ...(runtime === "node" || runtime === "pure"
-    //     ? {
-    //         stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
-    //         stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
-    //       }
-    //     : {
-    //         info: fs.createWriteStream(`${safeDest}/info.log`),
-    //         warn: fs.createWriteStream(`${safeDest}/warn.log`),
-    //         error: fs.createWriteStream(`${safeDest}/error.log`),
-    //         debug: fs.createWriteStream(`${safeDest}/debug.log`),
-    //       }),
-    // };
-
-    return {
-      ...streams,
-      closeAll: () => {
-        Object.values(streams).forEach(
-          (stream) => !stream.closed && stream.close()
-        );
-      },
-      writeExitCode: (code: number, error?: Error) => {
-        if (error) {
-          streams.exit.write(`Error: ${error.message}\n`);
-          if (error.stack) {
-            streams.exit.write(`Stack Trace:\n${error.stack}\n`);
-          }
-        }
-        streams.exit.write(`${code}\n`);
-      },
-      exit: streams.exit,
-    };
-  } catch (e) {
-    console.error(`Failed to create log streams in ${safeDest}:`, e);
-    throw e;
-  }
-}
-
-async function fileHash(filePath, algorithm = "md5") {
-  return new Promise<string>((resolve, reject) => {
-    const hash = crypto.createHash(algorithm);
-    const fileStream = fs.createReadStream(filePath);
+export class PM_Main extends PM_WithProcesses {
+  launchPure = async (src: string, dest: string) => {
+    const processId = `pure-${src}-${Date.now()}`;
+    const command = `pure test: ${src}`;
 
-    fileStream.on("data", (data) => {
-      hash.update(data);
-    });
+    // Create the promise
+    const purePromise = (async () => {
+      this.bddTestIsRunning(src);
 
-    fileStream.on("end", () => {
-      const fileHash = hash.digest("hex");
-      resolve(fileHash);
-    });
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/pure`;
 
-    fileStream.on("error", (error) => {
-      reject(`Error reading file: ${error.message}`);
-    });
-  });
-}
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-const statusMessagePretty = (
-  failures: number,
-  test: string,
-  runtime: IRunTime
-) => {
-  if (failures === 0) {
-    console.log(ansiC.green(ansiC.inverse(`${runtime} > ${test}`)));
-  } else if (failures > 0) {
-    console.log(
-      ansiC.red(
-        ansiC.inverse(
-          `${runtime} > ${test} failed ${failures} times (exit code: ${failures})`
-        )
-      )
-    );
-  } else {
-    console.log(
-      ansiC.red(ansiC.inverse(`${runtime} > ${test} crashed (exit code: -1)`))
-    );
-  }
-};
-
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path.dirname(filePath);
-
-  try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.writeFileSync(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
+      const destFolder = dest.replace(".mjs", "");
 
-const filesHash = async (files: string[], algorithm = "md5") => {
-  return new Promise<string>((resolve, reject) => {
-    resolve(
-      files.reduce(async (mm: Promise<string>, f) => {
-        return (await mm) + (await fileHash(f));
-      }, Promise.resolve(""))
-    );
-  });
-};
-
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
+      let argz = "";
 
-// Wait for file to exist, checks every 2 seconds by default
-async function pollForFile(path, timeout = 2000) {
-  const intervalObj = setInterval(function () {
-    const file = path;
-    const fileExists = fs.existsSync(file);
-    if (fileExists) {
-      clearInterval(intervalObj);
-    }
-  }, timeout);
-}
+      const testConfig = this.configs.tests.find((t) => {
+        return t[0] === src;
+      });
 
-export class PM_Main extends PM_WithEslintAndTsc {
-  ports: Record<number, string>;
-  queue: string[];
-  logStreams: Record<string, ReturnType<typeof createLogStreams>> = {};
-  webMetafileWatcher: fs.FSWatcher;
-  nodeMetafileWatcher: fs.FSWatcher;
-  importMetafileWatcher: fs.FSWatcher;
-  pitonoMetafileWatcher: fs.FSWatcher;
-  pureSidecars: Record<number, Sidecar>;
-  nodeSidecars: Record<number, ChildProcess>;
-  webSidecars: Record<number, Page>;
-  sidecars: Record<number, any> = {};
-  launchers: Record<string, () => void>;
-
-  wss: WebSocketServer;
-  clients: Set<any> = new Set();
-  httpServer: http.Server;
-  runningProcesses: Map<string, ChildProcess> = new Map();
-  allProcesses: Map<
-    string,
-    {
-      child?: ChildProcess;
-      status: "running" | "exited" | "error";
-      exitCode?: number;
-      error?: string;
-      command: string;
-      pid?: number;
-      timestamp: string;
-    }
-  > = new Map();
-  processLogs: Map<string, string[]> = new Map();
-
-  constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
-    super(configs, name, mode);
-
-    this.launchers = {};
-    this.ports = {};
-    this.queue = [];
-
-    this.nodeSidecars = {};
-    this.webSidecars = {};
-    this.pureSidecars = {};
-
-    this.configs.ports.forEach((element) => {
-      this.ports[element] = ""; // set ports as open
-    });
-
-    // Create HTTP server
-    this.httpServer = http.createServer(this.requestHandler.bind(this));
-
-    // Start WebSocket server attached to the HTTP server
-    this.wss = new WebSocketServer({ server: this.httpServer });
-
-    this.wss.on("connection", (ws) => {
-      this.clients.add(ws);
-      console.log("Client connected");
-
-      ws.on("message", (data) => {
-        try {
-          const message = JSON.parse(data.toString());
-          if (message.type === "executeCommand") {
-            // Validate the command starts with 'aider'
-            if (message.command && message.command.trim().startsWith("aider")) {
-              console.log(`Executing command: ${message.command}`);
-              // Execute the command
-              const processId = Date.now().toString();
-              const child = spawn(message.command, {
-                shell: true,
-                cwd: process.cwd(),
-              });
+      if (!testConfig) {
+        console.log(
+          ansiC.inverse("missing test config! Exiting ungracefully!")
+        );
+        process.exit(-1);
+      }
+      const testConfigResource = testConfig[2];
 
-              // Track the process in both maps
-              this.runningProcesses.set(processId, child);
-              this.allProcesses.set(processId, {
-                child,
-                status: "running",
-                command: message.command,
-                pid: child.pid,
-                timestamp: new Date().toISOString(),
-              });
+      const portsToUse: string[] = [];
+      if (testConfigResource.ports === 0) {
+        argz = JSON.stringify({
+          scheduled: true,
+          name: src,
+          ports: portsToUse,
+          fs: reportDest,
+          browserWSEndpoint: this.browser.wsEndpoint(),
+        });
+      } else if (testConfigResource.ports > 0) {
+        const openPorts = Object.entries(this.ports).filter(
+          ([portnumber, status]) => status === ""
+        );
 
-              // Initialize logs for this process
-              this.processLogs.set(processId, []);
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
 
-              // Broadcast process started
-              this.broadcast({
-                type: "processStarted",
-                processId,
-                command: message.command,
-                timestamp: new Date().toISOString(),
-                logs: [],
-              });
+            this.ports[openPorts[i][0]] = src; // port is now claimed
+          }
 
-              // Capture stdout and stderr
-              child.stdout?.on("data", (data) => {
-                const logData = data.toString();
-                // Add to stored logs
-                const logs = this.processLogs.get(processId) || [];
-                logs.push(logData);
-                this.processLogs.set(processId, logs);
-
-                this.broadcast({
-                  type: "processStdout",
-                  processId,
-                  data: logData,
-                  timestamp: new Date().toISOString(),
-                });
-              });
+          argz = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: portsToUse,
+            fs: destFolder,
+            browserWSEndpoint: this.browser.wsEndpoint(),
+          });
+        } else {
+          this.queue.push(src);
+          return [Math.random(), argz];
+        }
+      } else {
+        console.error("negative port makes no sense", src);
+        process.exit(-1);
+      }
 
-              child.stderr?.on("data", (data) => {
-                const logData = data.toString();
-                // Add to stored logs
-                const logs = this.processLogs.get(processId) || [];
-                logs.push(logData);
-                this.processLogs.set(processId, logs);
-
-                this.broadcast({
-                  type: "processStderr",
-                  processId,
-                  data: logData,
-                  timestamp: new Date().toISOString(),
-                });
-              });
+      const builtfile = dest;
 
-              child.on("error", (error) => {
-                console.error(`Failed to execute command: ${error}`);
-                this.runningProcesses.delete(processId);
-                // Update the process status to error
-                const processInfo = this.allProcesses.get(processId);
-                if (processInfo) {
-                  this.allProcesses.set(processId, {
-                    ...processInfo,
-                    status: "error",
-                    error: error.message,
-                  });
-                }
-                this.broadcast({
-                  type: "processError",
-                  processId,
-                  error: error.message,
-                  timestamp: new Date().toISOString(),
-                });
-              });
+      const logs = createLogStreams(reportDest, "pure");
 
-              child.on("exit", (code) => {
-                console.log(`Command exited with code ${code}`);
-                // Remove from running processes but keep in allProcesses
-                this.runningProcesses.delete(processId);
-                // Update the process status to exited
-                const processInfo = this.allProcesses.get(processId);
-                if (processInfo) {
-                  this.allProcesses.set(processId, {
-                    ...processInfo,
-                    status: "exited",
-                    exitCode: code,
-                  });
-                }
-                this.broadcast({
-                  type: "processExited",
-                  processId,
-                  exitCode: code,
-                  timestamp: new Date().toISOString(),
+      try {
+        await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+          return module.default
+            .then((defaultModule) => {
+              return defaultModule
+                .receiveTestResourceConfig(argz)
+                .then(async (results: IFinalResults) => {
+                  statusMessagePretty(results.fails, src, "pure");
+                  this.bddTestIsNowDone(src, results.fails);
+                  return results.fails;
                 });
-              });
-            } else {
-              console.error('Invalid command: must start with "aider"');
-            }
-          } else if (message.type === "getRunningProcesses") {
-            // Send list of all processes (both running and completed) with their full logs
-            const processes = Array.from(this.allProcesses.entries()).map(
-              ([id, procInfo]) => ({
-                processId: id,
-                command: procInfo.command,
-                pid: procInfo.pid,
-                status: procInfo.status,
-                exitCode: procInfo.exitCode,
-                error: procInfo.error,
-                timestamp: procInfo.timestamp,
-                logs: this.processLogs.get(id) || [],
-              })
-            );
-            ws.send(
-              JSON.stringify({
-                type: "runningProcesses",
-                processes,
-              })
-            );
-          } else if (message.type === "getProcess") {
-            // Send specific process with full logs
-            const processId = message.processId;
-            const procInfo = this.allProcesses.get(processId);
-            if (procInfo) {
-              ws.send(
-                JSON.stringify({
-                  type: "processData",
-                  processId,
-                  command: procInfo.command,
-                  pid: procInfo.pid,
-                  status: procInfo.status,
-                  exitCode: procInfo.exitCode,
-                  error: procInfo.error,
-                  timestamp: procInfo.timestamp,
-                  logs: this.processLogs.get(processId) || [],
-                })
-              );
-            }
-          } else if (message.type === "stdin") {
-            // Handle stdin input for a process
-            const processId = message.processId;
-            const data = message.data;
-            console.log("Received stdin for process", processId, ":", data);
-            const childProcess = this.runningProcesses.get(processId);
-
-            if (childProcess && childProcess.stdin) {
-              console.log("Writing to process stdin");
-              childProcess.stdin.write(data);
-            } else {
+            })
+            .catch((e2) => {
               console.log(
-                "Cannot write to stdin - process not found or no stdin:",
-                {
-                  processExists: !!childProcess,
-                  stdinExists: childProcess?.stdin ? true : false,
-                }
+                ansiColors.red(
+                  `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
+                )
               );
-            }
-          } else if (message.type === "killProcess") {
-            // Handle killing a process
-            const processId = message.processId;
-            console.log("Received killProcess for process", processId);
-            const childProcess = this.runningProcesses.get(processId);
-
-            if (childProcess) {
-              console.log("Killing process");
-              childProcess.kill("SIGTERM");
-              // The process exit handler will update the status and broadcast the change
-            } else {
-              console.log("Cannot kill process - process not found:", {
-                processExists: !!childProcess,
-              });
-            }
-          }
-        } catch (error) {
-          console.error("Error handling WebSocket message:", error);
-        }
-      });
-
-      ws.on("close", () => {
-        this.clients.delete(ws);
-        console.log("Client disconnected");
-      });
 
-      ws.on("error", (error) => {
-        console.error("WebSocket error:", error);
-        this.clients.delete(ws);
-      });
-    });
-
-    // Start HTTP server
-    const httpPort = Number(process.env.HTTP_PORT) || 3000;
-    this.httpServer.listen(httpPort, () => {
-      console.log(`HTTP server running on http://localhost:${httpPort}`);
-    });
-  }
-
-  async stopSideCar(uid: number): Promise<any> {
-    console.log(ansiC.green(ansiC.inverse(`stopSideCar ${uid}`)));
-
-    Object.entries(this.pureSidecars).forEach(async ([k, v]) => {
-      if (Number(k) === uid) {
-        await this.pureSidecars[Number(k)].stop();
-        delete this.pureSidecars[Number(k)];
-      }
-    });
-
-    Object.entries(this.nodeSidecars).forEach(async ([k, v]) => {
-      if (Number(k) === uid) {
-        await this.nodeSidecars[Number(k)].send("stop");
-        delete this.nodeSidecars[Number(k)];
-      }
-    });
-
-    Object.entries(this.webSidecars).forEach(async ([k, v]) => {
-      if (Number(k) === uid) {
-        (await this.browser.pages()).forEach(async (p) => {
-          if (p.mainFrame()._id === k) {
-            await this.webSidecars[Number(k)].close();
-            delete this.webSidecars[Number(k)];
-          }
+              logs.exit.write(e2.stack);
+              logs.exit.write(-1);
+              this.bddTestIsNowDone(src, -1);
+              statusMessagePretty(-1, src, "pure");
+              throw e2;
+            });
         });
-      }
-    });
-
-    return;
-  }
-
-  async launchSideCar(
-    n: number,
-    name: string
-  ): Promise<[number, ITTestResourceConfiguration]> {
-    const c = this.configs.tests.find(([v, r]) => {
-      return v === name;
-    }) as ITestTypes;
-
-    const s = c[3][n];
-
-    const r = s[1];
-    if (r === "node") {
-      return this.launchNodeSideCar(s);
-    } else if (r === "web") {
-      return this.launchWebSideCar(s);
-    } else if (r === "pure") {
-      return this.launchPureSideCar(s);
-    } else {
-      throw `unknown runtime ${r}`;
-    }
-  }
-
-  mapping(): [string, (...a) => any][] {
-    return [
-      ["$", this.$],
-      ["click", this.click],
-      ["closePage", this.closePage],
-      ["createWriteStream", this.createWriteStream],
-      ["customclose", this.customclose],
-      ["customScreenShot", this.customScreenShot.bind(this)],
-      ["end", this.end],
-      ["existsSync", this.existsSync],
-      ["focusOn", this.focusOn],
-      ["getAttribute", this.getAttribute],
-      ["getInnerHtml", this.getInnerHtml],
-      // ["setValue", this.setValue],
-      ["goto", this.goto.bind(this)],
-      ["isDisabled", this.isDisabled],
-      ["launchSideCar", this.launchSideCar.bind(this)],
-      ["mkdirSync", this.mkdirSync],
-      ["newPage", this.newPage],
-      ["page", this.page],
-      ["pages", this.pages],
-      ["screencast", this.screencast],
-      ["screencastStop", this.screencastStop],
-      ["stopSideCar", this.stopSideCar.bind(this)],
-      ["typeInto", this.typeInto],
-      ["waitForSelector", this.waitForSelector],
-      ["write", this.write],
-      ["writeFileSync", this.writeFileSync],
-    ];
-  }
-
-  async start() {
-    // set up the "pure" listeners
-    this.mapping().forEach(async ([command, func]) => {
-      globalThis[command] = func;
-    });
-
-    if (!fs.existsSync(`testeranto/reports/${this.name}`)) {
-      fs.mkdirSync(`testeranto/reports/${this.name}`);
-    }
-
-    const executablePath = "/opt/homebrew/bin/chromium";
-
-    try {
-      this.browser = await puppeteer.launch({
-        slowMo: 1,
-        waitForInitialPage: false,
-        executablePath,
-        headless: true,
-        defaultViewport: null, // Disable default 800x600 viewport
-        dumpio: false,
-        devtools: false,
-
-        args: [
-          "--allow-file-access-from-files",
-          "--allow-insecure-localhost",
-          "--allow-running-insecure-content",
-          "--auto-open-devtools-for-tabs",
-          "--disable-dev-shm-usage",
-          "--disable-extensions",
-          "--disable-features=site-per-process",
-          "--disable-gpu",
-          "--disable-setuid-sandbox",
-          "--disable-site-isolation-trials",
-          "--disable-web-security",
-          "--no-first-run",
-          "--no-sandbox",
-          "--no-startup-window",
-          "--reduce-security-for-testing",
-          "--remote-allow-origins=*",
-          "--start-maximized",
-          "--unsafely-treat-insecure-origin-as-secure=*",
-          `--remote-debugging-port=3234`,
-          // "--disable-features=IsolateOrigins,site-per-process",
-          // "--disable-features=IsolateOrigins",
-          // "--disk-cache-dir=/dev/null",
-          // "--disk-cache-size=1",
-          // "--no-zygote",
-          // "--remote-allow-origins=ws://localhost:3234",
-          // "--single-process",
-          // "--start-maximized",
-          // "--unsafely-treat-insecure-origin-as-secure",
-          // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-        ],
-      });
-    } catch (e) {
-      console.error(e);
-      console.error(
-        "could not start chrome via puppeter. Check this path: ",
-        executablePath
-      );
-    }
-
-    const { nodeEntryPoints, webEntryPoints, pureEntryPoints, pitonoEntryPoints } =
-      this.getRunnables(this.configs.tests, this.name);
-
-    [
-      [
-        nodeEntryPoints,
-        this.launchNode,
-        "node",
-        (w) => {
-          this.nodeMetafileWatcher = w;
-        },
-      ],
-      [
-        webEntryPoints,
-        this.launchWeb,
-        "web",
-        (w) => {
-          this.webMetafileWatcher = w;
-        },
-      ],
-      [
-        pureEntryPoints,
-        this.launchPure,
-        "pure",
-        (w) => {
-          this.importMetafileWatcher = w;
-        },
-      ],
-      [
-        pitonoEntryPoints,
-        this.launchPitono,
-        "pitono",
-        (w) => {
-          this.pitonoMetafileWatcher = w;
-        },
-      ],
-    ].forEach(
-      async ([eps, launcher, runtime, watcher]: [
-        Record<string, string>,
-        (src: string, dest: string) => Promise<void>,
-        IRunTime,
-        (f: fs.FSWatcher) => void
-      ]) => {
-        let metafile: string;
-        if (runtime === "pitono") {
-          metafile = `./testeranto/metafiles/python/core.json`;
-          // Ensure the directory exists before trying to watch
-          const metafileDir = path.dirname(metafile);
-          if (!fs.existsSync(metafileDir)) {
-            fs.mkdirSync(metafileDir, { recursive: true });
-          }
-        } else {
-          metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
-        }
-
-        // Only poll for file if it's not a pitono runtime
-        if (runtime !== "pitono") {
-          await pollForFile(metafile);
-        }
-
-        Object.entries(eps).forEach(
-          async ([inputFile, outputFile]: [string, string]) => {
-            // await pollForFile(outputFile);\
-
-            this.launchers[inputFile] = () => launcher(inputFile, outputFile);
-            this.launchers[inputFile]();
-
-            try {
-              watch(outputFile, async (e, filename) => {
-                const hash = await fileHash(outputFile);
-                if (fileHashes[inputFile] !== hash) {
-                  fileHashes[inputFile] = hash;
-                  console.log(
-                    ansiC.yellow(ansiC.inverse(`< ${e} ${filename}`))
-                  );
-                  // launcher(inputFile, outputFile);
-                  this.launchers[inputFile]();
-                }
-              });
-            } catch (e) {
-              console.error(e);
-            }
-          }
+      } catch (e3) {
+        logs.writeExitCode(-1, e3);
+        console.log(
+          ansiC.red(
+            ansiC.inverse(
+              `${src} 1 errored with: ${e3}. Check logs for more info`
+            )
+          )
         );
 
-        this.metafileOutputs(runtime);
-
-        // For pitono, we need to wait for the file to be created
-        if (runtime === "pitono") {
-          // Use polling to wait for the file to exist
-          const checkFileExists = () => {
-            if (fs.existsSync(metafile)) {
-              console.log(
-                ansiC.green(ansiC.inverse(`Pitono metafile found: ${metafile}`))
-              );
-              // Set up the watcher once the file exists
-              watcher(
-                watch(metafile, async (e, filename) => {
-                  console.log(
-                    ansiC.yellow(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
-                  );
-                  this.metafileOutputs(runtime);
-                })
-              );
-              // Read the metafile immediately
-              this.metafileOutputs(runtime);
-            } else {
-              // Check again after a delay
-              setTimeout(checkFileExists, 1000);
-            }
-          };
-          // Start checking for the file
-          checkFileExists();
-        } else {
-          // For other runtimes, only set up watcher if the file exists
-          if (fs.existsSync(metafile)) {
-            watcher(
-              watch(metafile, async (e, filename) => {
-                console.log(
-                  ansiC.yellow(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
-                );
-                this.metafileOutputs(runtime);
-              })
-            );
+        logs.exit.write(e3.stack);
+        logs.exit.write("-1");
+        this.bddTestIsNowDone(src, -1);
+        statusMessagePretty(-1, src, "pure");
+        throw e3;
+      } finally {
+        for (let i = 0; i <= portsToUse.length; i++) {
+          if (portsToUse[i]) {
+            this.ports[portsToUse[i]] = ""; // port is open again
           }
         }
       }
+    })();
+
+    // Add to process manager
+    this.addPromiseProcess(
+      processId,
+      purePromise,
+      command,
+      "bdd-test",
+      src,
+      "pure"
     );
-
-    // Object.keys(this.configs.externalTests).forEach((et) => {
-    //   this.launchExternalTest(et, this.configs.externalTests[et]);
-    // });
-  }
-
-  // async launchExternalTest(
-  //   externalTestName: string,
-  //   externalTest: {
-  //     watch: string[];
-  //     exec: string;
-  //   }
-  // ) {
-  //   // fs.mkdirSync(`testeranto/externalTests/${externalTestName}`);
-  //   // exec(externalTest.exec, (error, stdout, stderr) => {
-  //   //   if (error) {
-  //   //     fs.writeFileSync(
-  //   //       `testeranto/externalTests/${externalTestName}/exitcode.txt`,
-  //   //       `${error.name}\n${error.message}\n${error.code}\n`
-  //   //     );
-  //   //   } else {
-  //   //     fs.writeFileSync(
-  //   //       `testeranto/externalTests/${externalTestName}/exitcode.txt`,
-  //   //       `0`
-  //   //     );
-  //   //   }
-  //   //   fs.writeFileSync(
-  //   //     `testeranto/externalTests/${externalTestName}/stdout.txt`,
-  //   //     stdout
-  //   //   );
-  //   //   fs.writeFileSync(
-  //   //     `testeranto/externalTests/${externalTestName}/stderr.txt`,
-  //   //     stderr
-  //   //   );
-  //   // });
-  // }
-
-  async stop() {
-    console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-    this.mode = "once";
-    this.nodeMetafileWatcher.close();
-    this.webMetafileWatcher.close();
-    this.importMetafileWatcher.close();
-    if (this.pitonoMetafileWatcher) {
-      this.pitonoMetafileWatcher.close();
-    }
-
-    // Close any remaining log streams
-    Object.values(this.logStreams || {}).forEach((logs) => logs.closeAll());
-
-    // Close WebSocket server
-    this.wss.close(() => {
-      console.log("WebSocket server closed");
-    });
-
-    // Close all client connections
-    this.clients.forEach((client) => {
-      client.terminate();
-    });
-    this.clients.clear();
-
-    // Close HTTP server
-    this.httpServer.close(() => {
-      console.log("HTTP server closed");
-    });
-
-    this.checkForShutdown();
-  }
-
-  getRunnables = (
-    tests: ITestTypes[],
-    testName: string,
-    payload = {
-      nodeEntryPoints: {},
-      nodeEntryPointSidecars: {},
-      webEntryPoints: {},
-      webEntryPointSidecars: {},
-      pureEntryPoints: {},
-      pureEntryPointSidecars: {},
-    }
-  ): IRunnables => {
-    return getRunnables(tests, testName, payload);
   };
 
-  async metafileOutputs(platform: IRunTime) {
-    let metafilePath: string;
-    if (platform === "pitono") {
-      metafilePath = `./testeranto/metafiles/python/core.json`;
-    } else {
-      metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
-    }
-    
-    // Check if the file exists
-    if (!fs.existsSync(metafilePath)) {
-      if (platform === "pitono") {
-        console.log(
-          ansiC.yellow(ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`))
-        );
-      }
-      return;
-    }
-    
-    let metafile;
-    try {
-      const fileContent = fs.readFileSync(metafilePath).toString();
-      const parsedData = JSON.parse(fileContent);
-      // Handle different metafile structures
-      if (platform === "pitono") {
-        // Pitono metafile might be the entire content or have a different structure
-        metafile = parsedData.metafile || parsedData;
-      } else {
-        metafile = parsedData.metafile;
-      }
-      if (!metafile) {
-        console.log(
-          ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
-        );
-        return;
-      }
-    } catch (error) {
-      console.error(`Error reading metafile at ${metafilePath}:`, error);
-      return;
-    }
-
-    const outputs: IOutputs = metafile.outputs;
-
-    Object.keys(outputs).forEach(async (k) => {
-      const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
-      if (!k.startsWith(pattern)) {
-        return false;
-      }
-
-      const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-        if (!fs.existsSync(i)) return false;
-        if (i.startsWith("node_modules")) return false;
-        if (i.startsWith("./node_modules")) return false;
-
-        return true;
-      });
-
-      const f = `${k.split(".").slice(0, -1).join(".")}/`;
-
-      if (!fs.existsSync(f)) {
-        fs.mkdirSync(f);
-      }
+  launchNode = async (src: string, dest: string) => {
+    const processId = `node-${src}-${Date.now()}`;
+    const command = `node test: ${src}`;
 
-      const entrypoint = outputs[k].entryPoint;
+    // Create the promise
+    const nodePromise = (async () => {
+      this.bddTestIsRunning(src);
 
-      if (entrypoint) {
-        const changeDigest = await filesHash(addableFiles);
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/node`;
 
-        if (changeDigest === changes[entrypoint]) {
-          // skip
-        } else {
-          changes[entrypoint] = changeDigest;
-          this.tscCheck({
-            platform,
-            addableFiles,
-            entrypoint: entrypoint,
-          });
-          this.eslintCheck(entrypoint, platform, addableFiles);
-          this.makePrompt(entrypoint, addableFiles, platform);
-        }
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
       }
-    });
-  }
-
-  launchPure = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`pure < ${src}`)));
-    this.bddTestIsRunning(src);
-
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/pure`;
-
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
-
-    const destFolder = dest.replace(".mjs", "");
 
-    let argz = "";
+      let testResources = "";
 
-    const testConfig = this.configs.tests.find((t) => {
-      return t[0] === src;
-    });
-
-    if (!testConfig) {
-      console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
-      process.exit(-1);
-    }
-    const testConfigResource = testConfig[2];
-
-    const portsToUse: string[] = [];
-    if (testConfigResource.ports === 0) {
-      argz = JSON.stringify({
-        scheduled: true,
-        name: src,
-        ports: portsToUse,
-        fs: reportDest,
-        browserWSEndpoint: this.browser.wsEndpoint(),
+      const testConfig = this.configs.tests.find((t) => {
+        return t[0] === src;
       });
-    } else if (testConfigResource.ports > 0) {
-      const openPorts = Object.entries(this.ports).filter(
-        ([portnumber, status]) => status === ""
-      );
 
-      if (openPorts.length >= testConfigResource.ports) {
-        for (let i = 0; i < testConfigResource.ports; i++) {
-          portsToUse.push(openPorts[i][0]);
-
-          this.ports[openPorts[i][0]] = src; // port is now claimed
-        }
-
-        argz = JSON.stringify({
-          scheduled: true,
-          name: src,
-          ports: portsToUse,
-          fs: destFolder,
-          browserWSEndpoint: this.browser.wsEndpoint(),
-        });
-      } else {
-        this.queue.push(src);
-        return [Math.random(), argz];
-      }
-    } else {
-      console.error("negative port makes no sense", src);
-      process.exit(-1);
-    }
-
-    const builtfile = dest;
-
-    // const webSideCares: Page[] = [];
-
-    // fs.writeFileSync(
-    //   `${reportDest}/stdlog.txt`,
-    //   "THIS FILE IS AUTO GENERATED. IT IS PURPOSEFULLY LEFT BLANK."
-    // );
-
-    // await Promise.all(
-    //   testConfig[3].map(async (sidecar) => {
-    //     if (sidecar[1] === "web") {
-    //       const s = await this.launchWebSideCar(
-    //         sidecar[0],
-    //         destinationOfRuntime(sidecar[0], "web", this.configs),
-    //         sidecar
-    //       );
-    //       webSideCares.push(s);
-    //       return s;
-    //     }
-
-    //     if (sidecar[1] === "node") {
-    //       return this.launchNodeSideCar(
-    //         sidecar[0],
-    //         destinationOfRuntime(sidecar[0], "node", this.configs),
-    //         sidecar
-    //       );
-    //     }
-    //   })
-    // );
-
-    const logs = createLogStreams(reportDest, "pure");
-
-    try {
-      await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-        // Override console methods to redirect logs
-        // Only override stdout/stderr methods for pure runtime
-        const originalConsole = { ...console };
-
-        // console.log = (...args) => {
-        //   logs.stdout.write(args.join(" ") + "\n");
-        //   originalConsole.log(...args);
-        // };
-
-        // console.error = (...args) => {
-        //   logs.stderr.write(args.join(" ") + "\n");
-        //   originalConsole.error(...args);
-        // };
-
-        return module.default
-          .then((defaultModule) => {
-            defaultModule
-              .receiveTestResourceConfig(argz)
-              .then(async (results: IFinalResults) => {
-                // this.receiveFeatures(results.features, destFolder, src, "pure");
-                // this.receiveFeaturesV2(reportDest, src, "pure");
-
-                statusMessagePretty(results.fails, src, "pure");
-                this.bddTestIsNowDone(src, results.fails);
-              })
-              .catch((e1) => {
-                console.log(
-                  ansiC.red(`launchPure - ${src} errored with: ${e1.stack}`)
-                );
-                this.bddTestIsNowDone(src, -1);
-                statusMessagePretty(-1, src, "pure");
-              });
-            // .finally(() => {
-            //   // webSideCares.forEach((webSideCar) => webSideCar.close());
-            // });
-          })
-          .catch((e2) => {
-            console.log(
-              ansiColors.red(
-                `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
-              )
-            );
-
-            logs.exit.write(e2.stack);
-            logs.exit.write(-1);
-            this.bddTestIsNowDone(src, -1);
-            statusMessagePretty(-1, src, "pure");
-            // console.error(e);
-          })
-          .finally((x) => {
-            // const fileSet = files[src] || new Set();
-            // fs.writeFileSync(
-            //   reportDest + "/manifest.json",
-            //   JSON.stringify(Array.from(fileSet))
-            // );
-          });
-      });
-    } catch (e3) {
-      logs.writeExitCode(-1, e3);
-      console.log(
-        ansiC.red(
+      if (!testConfig) {
+        console.log(
           ansiC.inverse(
-            `${src} 1 errored with: ${e3}. Check logs for more info`
+            `missing test config! Exiting ungracefully for '${src}'`
           )
-        )
-      );
-
-      logs.exit.write(e3.stack);
-      logs.exit.write("-1");
-      this.bddTestIsNowDone(src, -1);
-      statusMessagePretty(-1, src, "pure");
-    }
-
-    for (let i = 0; i <= portsToUse.length; i++) {
-      if (portsToUse[i]) {
-        this.ports[portsToUse[i]] = ""; //port is open again
+        );
+        process.exit(-1);
       }
-    }
-  };
-
-  launchNode = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`node < ${src}`)));
-    this.bddTestIsRunning(src);
-
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/node`;
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
-
-    // const destFolder = dest.replace(".mjs", "");
-
-    let testResources = "";
-
-    const testConfig = this.configs.tests.find((t) => {
-      return t[0] === src;
-    });
-
-    if (!testConfig) {
-      console.log(
-        ansiC.inverse(`missing test config! Exiting ungracefully for '${src}'`)
-      );
-      process.exit(-1);
-    }
-    const testConfigResource = testConfig[2];
-
-    const portsToUse: string[] = [];
-    if (testConfigResource.ports === 0) {
-      const t: ITTestResourceConfiguration = {
-        name: src,
-        // ports: portsToUse.map((v) => Number(v)),
-        ports: [],
-        fs: reportDest,
-        browserWSEndpoint: this.browser.wsEndpoint(),
-      };
 
-      testResources = JSON.stringify(t);
-    } else if (testConfigResource.ports > 0) {
-      const openPorts: [string, string][] = Object.entries(this.ports).filter(
-        ([portnumber, portopen]) => portopen === ""
-      );
+      const testConfigResource = testConfig[2];
 
-      if (openPorts.length >= testConfigResource.ports) {
-        for (let i = 0; i < testConfigResource.ports; i++) {
-          portsToUse.push(openPorts[i][0]); // Convert string port to number
+      const portsToUse: string[] = [];
 
-          this.ports[openPorts[i][0]] = src; // port is now claimed
-        }
-
-        testResources = JSON.stringify({
-          scheduled: true,
+      if (testConfigResource.ports === 0) {
+        const t: ITTestResourceConfiguration = {
           name: src,
-          ports: portsToUse,
+          ports: [],
           fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint(),
-        });
-      } else {
-        console.log(
-          ansiC.red(
-            `node: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again run a port is available`
-          )
-        );
-        this.queue.push(src);
-        return [Math.random(), argz]; // Add this return
-      }
-    } else {
-      console.error("negative port makes no sense", src);
-      process.exit(-1);
-    }
-
-    const builtfile = dest;
-
-    let haltReturns = false;
-
-    const ipcfile = "/tmp/tpipe_" + Math.random();
-    const child = spawn(
-      "node",
-      // "node",
-      [
-        // "--inspect-brk",
-        builtfile,
-        testResources,
-        ipcfile,
-      ],
-      {
-        stdio: ["pipe", "pipe", "pipe", "ipc"],
-      }
-    );
-
-    let buffer: Buffer<ArrayBufferLike> = new Buffer("");
-
-    const server = net.createServer((socket) => {
-      const queue = new Queue<string[]>();
+        };
 
-      socket.on("data", (data) => {
-        buffer = Buffer.concat([buffer, data]);
+        testResources = JSON.stringify(t);
+      } else if (testConfigResource.ports > 0) {
+        const openPorts: [string, string][] = Object.entries(this.ports).filter(
+          ([portnumber, portopen]) => portopen === ""
+        );
 
-        for (let b = 0; b < buffer.length + 1; b++) {
-          const c = buffer.slice(0, b);
-          let d;
-          try {
-            d = JSON.parse(c.toString());
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
 
-            queue.enqueue(d);
-            buffer = buffer.slice(b, buffer.length + 1);
-            b = 0;
-          } catch (e) {
-            // b++;
+            this.ports[openPorts[i][0]] = src; // port is now claimed
           }
-        }
 
-        while (queue.size() > 0) {
-          const message = queue.dequeue();
-
-          if (message) {
-            // set up the "node" listeners
-            this.mapping().forEach(async ([command, func]) => {
-              if (message[0] === command) {
-                const x = message.slice(1, -1);
-                const r = await this[command](...x);
-
-                if (!haltReturns) {
-                  child.send(
-                    JSON.stringify({
-                      payload: r,
-                      key: message[message.length - 1],
-                    })
-                  );
-                }
-              }
-            });
-          }
-        }
-      });
-    });
-
-    const logs = createLogStreams(reportDest, "node");
-
-    server.listen(ipcfile, () => {
-      // Only handle stdout/stderr for node runtime
-      child.stdout?.on("data", (data) => {
-        logs.stdout?.write(data); // Add null check
-      });
-
-      child.stderr?.on("data", (data) => {
-        logs.stderr?.write(data); // Add null check
-      });
-      child.on("error", (err) => {});
-      child.on("close", (code) => {
-        const exitCode = code === null ? -1 : code;
-        if (exitCode < 0) {
-          logs.writeExitCode(
-            exitCode,
-            new Error("Process crashed or was terminated")
-          );
+          testResources = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: portsToUse,
+            fs: reportDest,
+            browserWSEndpoint: this.browser.wsEndpoint(),
+          });
         } else {
-          logs.writeExitCode(exitCode);
-        }
-        logs.closeAll();
-        server.close();
-
-        if (!files[src]) {
-          files[src] = new Set();
-        }
-
-        if (exitCode === 255) {
           console.log(
-            ansiColors.red(
-              `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/stderr.log for more info`
+            ansiC.red(
+              `node: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again run a port is available`
             )
           );
-          this.bddTestIsNowDone(src, -1);
-          statusMessagePretty(-1, src, "node");
-          return;
-        } else if (exitCode === 0) {
-          this.bddTestIsNowDone(src, 0);
-          statusMessagePretty(0, src, "node");
-        } else {
-          this.bddTestIsNowDone(src, exitCode);
-          statusMessagePretty(exitCode, src, "node");
+          this.queue.push(src);
+          return [Math.random(), testResources];
         }
+      } else {
+        console.error("negative port makes no sense", src);
+        process.exit(-1);
+      }
 
-        haltReturns = true;
-      });
-      child.on("exit", (code) => {
-        haltReturns = true;
-
-        for (let i = 0; i <= portsToUse.length; i++) {
-          if (portsToUse[i]) {
-            this.ports[portsToUse[i]] = ""; //port is open again
-          }
-        }
-      });
-      child.on("error", (e) => {
-        console.log("error");
+      const builtfile = dest;
 
-        haltReturns = true;
+      let haltReturns = false;
 
-        console.log(
-          ansiC.red(
-            ansiC.inverse(
-              `${src} errored with: ${e.name}. Check error logs for more info`
-            )
-          )
-        );
-        this.bddTestIsNowDone(src, -1);
-        statusMessagePretty(-1, src, "node");
+      const ipcfile = "/tmp/tpipe_" + Math.random();
+      const child = spawn("node", [builtfile, testResources, ipcfile], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
       });
-    });
-  };
 
-  launchWebSideCar = async (
-    testConfig: ITestTypes
-  ): Promise<[number, Page]> => {
-    const src = testConfig[0];
-    const dest = src.split(".").slice(0, -1).join(".");
-    // const d = dest + ".mjs";
+      let buffer: Buffer<ArrayBufferLike> = new Buffer("");
 
-    const destFolder = dest.replace(".mjs", "");
+      const server = net.createServer((socket) => {
+        const queue = new Queue<string[]>();
 
-    console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
+        socket.on("data", (data) => {
+          buffer = Buffer.concat([buffer, data]);
 
-    // const fileStreams2: fs.WriteStream[] = [];
-    // const doneFileStream2: Promise<any>[] = [];
-
-    const logs = createLogStreams(dest, "web");
-
-    return new Promise((res, rej) => {
-      this.browser
-        .newPage()
-        .then(async (page) => {
-          this.mapping().forEach(async ([command, func]) => {
-            page.exposeFunction(command, func);
-          });
-
-          const close = () => {
-            if (!files[src]) {
-              files[src] = new Set();
-            }
-            // files[src].add(filepath);
-
-            // fs.writeFileSync(
-            //   destFolder + "/manifest.json",
-            //   JSON.stringify(Array.from(files[src]))
-            // );
-
-            delete files[src];
-
-            Promise.all(screenshots[src] || []).then(() => {
-              delete screenshots[src];
-              page.close();
-            });
-          };
-
-          page.on("pageerror", (err: Error) => {
-            console.debug(`Error from ${src}: [${err.name}] `);
-            console.debug(`Error from ${src}: [${err.name}] `);
-            if (err.cause) {
-              console.debug(`Error from ${src} cause: [${err.cause}] `);
-            }
-            if (err.stack) {
-              console.debug(`Error from stack ${src}: [${err.stack}] `);
-            }
-            console.debug(`Error from message ${src}: [${err.message}] `);
-            this.bddTestIsNowDone(src, -1);
-            close();
-          });
+          for (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            let d;
+            try {
+              d = JSON.parse(c.toString());
 
-          page.on("console", (log: ConsoleMessage) => {
-            const msg = `${log.text()}\n${JSON.stringify(
-              log.location()
-            )}\n${JSON.stringify(log.stackTrace())}\n`;
-            switch (log.type()) {
-              case "info":
-                logs.info?.write(msg);
-                break;
-              case "warn":
-                logs.warn?.write(msg);
-                break;
-              case "error":
-                logs.error?.write(msg);
-                break;
-              case "debug":
-                logs.debug?.write(msg);
-                break;
-              default:
-                break;
+              queue.enqueue(d);
+              buffer = buffer.slice(b, buffer.length + 1);
+              b = 0;
+            } catch (e) {
+              // b++;
             }
-          });
-
-          await page.goto(`file://${`${destFolder}.html`}`, {});
-
-          const webArgz = JSON.stringify({
-            name: dest,
-            ports: [].toString(),
-            fs: dest,
-            browserWSEndpoint: this.browser.wsEndpoint(),
-          });
-
-          const d = `${dest}?cacheBust=${Date.now()}`;
-
-          const evaluation = `
-    import('${d}').then(async (x) => {
-
-      try {
-        return await (await x.default).receiveTestResourceConfig(${webArgz})
-      } catch (e) {
-        console.log("fail", e.toString())
-      }
-    })`;
-
-          await page
-            .evaluate(evaluation)
-            .then(async ({ fails, failed, features }: IFinalResults) => {
-              // this.receiveFeatures(features, destFolder, src, "web");
-              // this.receiveFeaturesV2(reportDest, src, "web");
-
-              statusMessagePretty(fails, src, "web");
-              this.bddTestIsNowDone(src, fails);
-            })
-            .catch((e) => {
-              console.log(
-                ansiC.red(
-                  ansiC.inverse(`launchWebSidecar - ${src} errored with: ${e}`)
-                )
-              );
-            })
-            .finally(() => {
-              this.bddTestIsNowDone(src, -1);
-              close();
-            });
-
-          return page;
-
-          // return page;
-        })
-        .then(async (page) => {
-          await page.goto(`file://${`${dest}.html`}`, {});
-
-          res([Math.random(), page]);
-        });
-    });
-  };
-
-  launchNodeSideCar = async (
-    sidecar: ITestTypes
-  ): Promise<[number, ITTestResourceConfiguration]> => {
-    const src = sidecar[0];
-    const dest =
-      process.cwd() + `/testeranto/bundles/node/${this.name}/${sidecar[0]}`;
-    const d = dest + ".mjs";
-    console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${sidecar[0]}`)));
-
-    const destFolder = dest.replace(".ts", "");
-
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/node`;
-
-    const argz: ITTestResourceConfiguration = {
-      name: sidecar[0],
-      ports: [],
-      fs: destFolder,
-      browserWSEndpoint: this.browser.wsEndpoint(),
-    };
-
-    const testReq: { ports: number } = sidecar[2];
-
-    const logs = createLogStreams(dest, "node");
-
-    const portsToUse: number[] = [];
-    if (testReq.ports === 0) {
-      // argz = {
-      //   name: sidecar[0],
-      //   ports: portsToUse,
-      //   fs: destFolder,
-      //   browserWSEndpoint: this.browser.wsEndpoint(),
-      // };
-    } else if (testReq.ports > 0) {
-      const openPorts = Object.entries(this.ports).filter(
-        ([portnumber, portopen]) => portopen === ""
-      );
-
-      if (openPorts.length >= testReq.ports) {
-        for (let i = 0; i < testReq.ports; i++) {
-          portsToUse.push(Number(openPorts[i][0])); // Convert string port to number
-
-          this.ports[openPorts[i][0]] = src; // port is now closed
-        }
-
-        argz.ports = portsToUse;
-
-        const builtfile = destFolder + ".mjs";
-
-        let haltReturns = false;
-
-        let buffer: Buffer<ArrayBufferLike> = new Buffer("");
-
-        const server = net.createServer((socket) => {
-          socket.on("data", (data) => {
-            buffer = Buffer.concat([buffer, data]);
+          }
 
-            const messages: string[][] = [];
-            for (let b = 0; b < buffer.length + 1; b++) {
-              const c = buffer.slice(0, b);
-              let d;
-              try {
-                d = JSON.parse(c.toString());
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
 
-                messages.push(d);
-                buffer = buffer.slice(b, buffer.length + 1);
-                b = 0;
-              } catch (e) {
-                // b++;
-              }
-            }
-
-            messages.forEach(async (payload) => {
+            if (message) {
+              // set up the "node" listeners
               this.mapping().forEach(async ([command, func]) => {
-                if (payload[0] === command) {
-                  const x = payload.slice(1, -1);
+                if (message[0] === command) {
+                  const x = message.slice(1, -1);
                   const r = await this[command](...x);
 
                   if (!haltReturns) {
                     child.send(
                       JSON.stringify({
                         payload: r,
-                        key: payload[payload.length - 1],
+                        key: message[message.length - 1],
                       })
                     );
                   }
                 }
-              });
-            });
-          });
+              });
+            }
+          }
         });
+      });
 
-        const child = spawn("node", [builtfile, JSON.stringify(argz)], {
-          stdio: ["pipe", "pipe", "pipe", "ipc"],
-          // silent: true
-        });
+      const logs = createLogStreams(reportDest, "node");
 
-        const p = "/tmp/tpipe" + Math.random();
+      return new Promise<void>((resolve, reject) => {
+        server.listen(ipcfile, () => {
+          child.stdout?.on("data", (data) => {
+            logs.stdout?.write(data);
+          });
 
-        server.listen(p, () => {
-          child.on("close", (code) => {
-            server.close();
-            haltReturns = true;
+          child.stderr?.on("data", (data) => {
+            logs.stderr?.write(data);
           });
-          child.on("exit", (code) => {
-            haltReturns = true;
 
-            for (let i = 0; i <= portsToUse.length; i++) {
-              if (portsToUse[i]) {
-                this.ports[portsToUse[i]] = ""; //port is open again
-              }
+          child.on("close", (code) => {
+            const exitCode = code === null ? -1 : code;
+            if (exitCode < 0) {
+              logs.writeExitCode(
+                exitCode,
+                new Error("Process crashed or was terminated")
+              );
+            } else {
+              logs.writeExitCode(exitCode);
             }
-          });
-          child.on("error", (e) => {
-            if (fs.existsSync(p)) {
-              fs.rmSync(p);
+            logs.closeAll();
+            server.close();
+
+            if (exitCode === 255) {
+              console.log(
+                ansiColors.red(
+                  `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/stderr.log for more info`
+                )
+              );
+              this.bddTestIsNowDone(src, -1);
+              statusMessagePretty(-1, src, "node");
+              reject(new Error(`Process exited with code ${exitCode}`));
+            } else if (exitCode === 0) {
+              this.bddTestIsNowDone(src, 0);
+              statusMessagePretty(0, src, "node");
+              resolve();
+            } else {
+              this.bddTestIsNowDone(src, exitCode);
+              statusMessagePretty(exitCode, src, "node");
+              reject(new Error(`Process exited with code ${exitCode}`));
             }
 
             haltReturns = true;
+          });
 
+          child.on("error", (e) => {
+            console.log("error");
+            haltReturns = true;
             console.log(
               ansiC.red(
                 ansiC.inverse(
-                  `launchNodeSideCar - ${src} errored with: ${e.name}. Check logs for more info`
+                  `${src} errored with: ${e.name}. Check error logs for more info`
                 )
               )
             );
-            logs.error?.write(e.toString() + "\n");
-            // this.bddTestIsNowDone(src, -1);
-            // statusMessagePretty(-1, src);
+            this.bddTestIsNowDone(src, -1);
+            statusMessagePretty(-1, src, "node");
+            reject(e);
           });
         });
+      }).finally(() => {
+        for (let i = 0; i <= portsToUse.length; i++) {
+          if (portsToUse[i]) {
+            this.ports[portsToUse[i]] = ""; //port is open again
+          }
+        }
+      });
+    })();
+
+    // Add to process manager
+    this.addPromiseProcess(
+      processId,
+      nodePromise,
+      command,
+      "bdd-test",
+      src,
+      "node"
+    );
+  };
 
-        child.send({ path: p });
+  launchWeb = async (src: string, dest: string) => {
+    const processId = `web-${src}-${Date.now()}`;
+    const command = `web test: ${src}`;
+
+    // Create the promise
+    const webPromise = (async () => {
+      this.bddTestIsRunning(src);
+
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/web`;
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-        const r = Math.random();
-        this.nodeSidecars[r] = child;
-        return [r, argz];
-      } else {
-        console.log(
-          ansiC.red(
-            `cannot ${src} because there are no open ports. the job will be unqueued`
-          )
-        );
+      const destFolder = dest.replace(".mjs", "");
 
-        this.queue.push(sidecar[0]);
-        return [Math.random(), argz];
-      }
-    } else {
-      console.error("negative port makes no sense", sidecar[0]);
-      process.exit(-1);
-    }
-  };
+      const webArgz = JSON.stringify({
+        name: src,
+        ports: [].toString(),
+        fs: reportDest,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+      });
+
+      const d = `${dest}?cacheBust=${Date.now()}`;
+
+      const logs = createLogStreams(reportDest, "web");
+
+      return new Promise<void>((resolve, reject) => {
+        this.browser
+          .newPage()
+          .then((page) => {
+            page.on("console", (log: ConsoleMessage) => {
+              const msg = `${log.text()}\n`;
+
+              switch (log.type()) {
+                case "info":
+                  logs.info?.write(msg);
+                  break;
+                case "warn":
+                  logs.warn?.write(msg);
+                  break;
+                case "error":
+                  logs.error?.write(msg);
+                  break;
+                case "debug":
+                  logs.debug?.write(msg);
+                  break;
+                default:
+                  break;
+              }
+            });
+
+            page.on("close", () => {
+              logs.writeExitCode(0);
+              logs.closeAll();
+            });
+
+            this.mapping().forEach(async ([command, func]) => {
+              if (command === "page") {
+                page.exposeFunction(command, (x?) => {
+                  if (x) {
+                    return func(x);
+                  } else {
+                    return func(page.mainFrame()._id);
+                  }
+                });
+              } else {
+                return page.exposeFunction(command, func);
+              }
+            });
+
+            return page;
+          })
+          .then(async (page) => {
+            const close = () => {
+              if (!files[src]) {
+                files[src] = new Set();
+              }
+
+              delete files[src];
 
-  stopPureSideCar = async (uid: number) => {
-    console.log(ansiC.green(ansiC.inverse(`stopPureSideCar ${uid}`)));
-    await this.sidecars[uid].shutdown();
-    return;
+              Promise.all(screenshots[src] || []).then(() => {
+                delete screenshots[src];
+                page.close();
+              });
+            };
+
+            page.on("pageerror", (err: Error) => {
+              logs.writeExitCode(-1, err);
+              console.log(
+                ansiColors.red(
+                  `web ! ${src} failed to execute No "tests.json" file was generated. Check ${reportDest}/error.log for more info`
+                )
+              );
+              this.bddTestIsNowDone(src, -1);
+              close();
+              reject(err);
+            });
+
+            await page.goto(`file://${`${destFolder}.html`}`, {});
+
+            await page
+              .evaluate(webEvaluator(d, webArgz))
+              .then(async ({ fails, failed, features }: IFinalResults) => {
+                statusMessagePretty(fails, src, "web");
+                this.bddTestIsNowDone(src, fails);
+                resolve();
+              })
+              .catch((e) => {
+                console.log(ansiC.red(ansiC.inverse(e.stack)));
+                console.log(
+                  ansiC.red(
+                    ansiC.inverse(
+                      `web ! ${src} failed to execute. No "tests.json" file was generated. Check logs for more info`
+                    )
+                  )
+                );
+                this.bddTestIsNowDone(src, -1);
+                reject(e);
+              })
+              .finally(() => {
+                close();
+              });
+          })
+          .catch((error) => {
+            reject(error);
+          });
+      });
+    })();
+
+    // Add to process manager
+    this.addPromiseProcess(
+      processId,
+      webPromise,
+      command,
+      "bdd-test",
+      src,
+      "web"
+    );
   };
 
-  launchPureSideCar = async (
-    sidecar: ITestTypes
-  ): Promise<[number, ITTestResourceConfiguration]> => {
-    console.log(ansiC.green(ansiC.inverse(`launchPureSideCar ${sidecar[0]}`)));
+  launchPython = async (src: string, dest: string) => {
+    const processId = `python-${src}-${Date.now()}`;
+    const command = `python test: ${src}`;
 
-    const r = Math.random();
+    const pythonPromise = (async () => {
+      this.bddTestIsRunning(src);
 
-    const dest =
-      process.cwd() + `/testeranto/bundles/pure/${this.name}/${sidecar[0]}`;
-    const builtfile = dest.split(".").slice(0, -1).concat("mjs").join(".");
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/python`;
 
-    const destFolder = dest.replace(".mjs", "");
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-    let argz: ITTestResourceConfiguration;
+      let testResources = "";
 
-    const z = sidecar[2];
-    const testConfigResource: { ports: number } = sidecar[2];
-    const src = sidecar[0];
+      const testConfig = this.configs.tests.find((t) => t[0] === src);
+      if (!testConfig) {
+        console.log(
+          ansiColors.inverse(
+            `missing test config! Exiting ungracefully for '${src}'`
+          )
+        );
+        process.exit(-1);
+      }
 
-    const portsToUse: number[] = [];
-    if (testConfigResource.ports === 0) {
-      argz = {
-        // scheduled: true,
-        name: src,
-        ports: portsToUse,
-        fs: destFolder,
-        browserWSEndpoint: this.browser.wsEndpoint(),
-      };
-    } else if (testConfigResource.ports > 0) {
-      const openPorts = Object.entries(this.ports).filter(
-        ([portnumber, portopen]) => portopen === ""
-      );
-      if (openPorts.length >= testConfigResource.ports) {
-        for (let i = 0; i < testConfigResource.ports; i++) {
-          portsToUse.push(Number(openPorts[i][0]));
-
-          this.ports[openPorts[i][0]] = src; // port is now claimed
-        }
+      const testConfigResource = testConfig[2];
+      const portsToUse: string[] = [];
 
-        argz = {
-          // scheduled: true,
+      if (testConfigResource.ports === 0) {
+        testResources = JSON.stringify({
+          scheduled: true,
           name: src,
-          // ports: [3333],
           ports: portsToUse,
-          fs: ".",
+          fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint(),
-        };
+        });
+      } else if (testConfigResource.ports > 0) {
+        const openPorts = Object.entries(this.ports).filter(
+          ([, status]) => status === ""
+        );
+
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
+            this.ports[openPorts[i][0]] = src;
+          }
+
+          testResources = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: portsToUse,
+            fs: reportDest,
+            browserWSEndpoint: this.browser.wsEndpoint(),
+          });
+        } else {
+          console.log(
+            ansiColors.red(
+              `python: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
+            )
+          );
+          this.queue.push(src);
+          return;
+        }
       } else {
-        this.queue.push(src);
-        // return;
+        console.error("negative port makes no sense", src);
+        process.exit(-1);
       }
-    } else {
-      console.error("negative port makes no sense", src);
-      process.exit(-1);
-    }
-
-    // const builtfile = dest + ".mjs";
-
-    await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-      if (!this.pureSidecars) this.pureSidecars = {};
-      this.pureSidecars[r] = module.default;
-      this.pureSidecars[r].start(argz);
-    });
-
-    return [r, argz];
-    // for (let i = 0; i <= portsToUse.length; i++) {
-    //   if (portsToUse[i]) {
-    //     this.ports[portsToUse[i]] = "true"; //port is open again
-    //   }
-    // }
-  };
 
-  launchPitono = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`pitono < ${src}`)));
-    this.bddTestIsRunning(src);
-
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/pitono`;
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
-
-    const logs = createLogStreams(reportDest, "node"); // Use node-style logs for pitono
-
-    try {
-      // Execute the Python test using the pitono runner
-      const { PitonoRunner } = await import('./pitonoRunner');
-      const runner = new PitonoRunner(this.configs, this.name);
-      await runner.run();
-      
-      this.bddTestIsNowDone(src, 0);
-      statusMessagePretty(0, src, "pitono");
-    } catch (error) {
-      logs.writeExitCode(-1, error);
-      console.log(
-        ansiC.red(
-          ansiC.inverse(
-            `${src} errored with: ${error}. Check logs for more info`
-          )
-        )
-      );
-      this.bddTestIsNowDone(src, -1);
-      statusMessagePretty(-1, src, "pitono");
-    }
-  };
+      const logs = createLogStreams(reportDest, "python");
 
-  launchWeb = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`web < ${src}`)));
-    this.bddTestIsRunning(src);
-
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/web`;
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
-
-    const destFolder = dest.replace(".mjs", "");
-
-    const webArgz = JSON.stringify({
-      name: src,
-      ports: [].toString(),
-      fs: reportDest,
-      browserWSEndpoint: this.browser.wsEndpoint(),
-    });
-
-    const d = `${dest}?cacheBust=${Date.now()}`;
-
-    const logs = createLogStreams(reportDest, "web");
-
-    this.browser
-      .newPage()
-      .then((page) => {
-        page.on("console", (log: ConsoleMessage) => {
-          const msg = `${log.text()}\n`;
-
-          switch (log.type()) {
-            case "info":
-              logs.info?.write(msg);
-              break;
-            case "warn":
-              logs.warn?.write(msg);
-              break;
-            case "error":
-              logs.error?.write(msg);
-              break;
-            case "debug":
-              logs.debug?.write(msg);
-              break;
-            default:
-              break;
-          }
+      // For Python, we'll just run the script directly and pass test resources as an argument
+      // Python tests need to handle their own IPC if needed
+      const child = spawn("python3", [src, testResources], {
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      return new Promise<void>((resolve, reject) => {
+        child.stdout?.on("data", (data) => {
+          logs.stdout?.write(data);
         });
 
-        page.on("close", () => {
-          logs.writeExitCode(0); // Web tests exit with 0 unless there's an error
-          logs.closeAll();
-          logs.closeAll();
+        child.stderr?.on("data", (data) => {
+          logs.stderr?.write(data);
         });
-        this.mapping().forEach(async ([command, func]) => {
-          if (command === "page") {
-            page.exposeFunction(command, (x?) => {
-              if (x) {
-                return func(x);
-              } else {
-                return func(page.mainFrame()._id);
-              }
-            });
+
+        child.on("close", (code) => {
+          const exitCode = code === null ? -1 : code;
+          if (exitCode < 0) {
+            logs.writeExitCode(
+              exitCode,
+              new Error("Process crashed or was terminated")
+            );
           } else {
-            return page.exposeFunction(command, func);
+            logs.writeExitCode(exitCode);
           }
-        });
+          logs.closeAll();
 
-        return page;
-      })
-      .then(async (page) => {
-        const close = () => {
-          if (!files[src]) {
-            files[src] = new Set();
+          if (exitCode === 0) {
+            this.bddTestIsNowDone(src, 0);
+            statusMessagePretty(0, src, "python");
+            resolve();
+          } else {
+            console.log(
+              ansiColors.red(
+                `python ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
+              )
+            );
+            this.bddTestIsNowDone(src, exitCode);
+            statusMessagePretty(exitCode, src, "python");
+            reject(new Error(`Process exited with code ${exitCode}`));
           }
-          // files[t].add(filepath);
-
-          // fs.writeFileSync(
-          //   destFolder + "/manifest.json",
-          //   JSON.stringify(Array.from(files[src]))
-          // );
-          delete files[src];
-
-          Promise.all(screenshots[src] || []).then(() => {
-            delete screenshots[src];
-            page.close();
-          });
-
-          return;
-        };
+        });
 
-        page.on("pageerror", (err: Error) => {
-          logs.writeExitCode(-1, err);
+        child.on("error", (e) => {
           console.log(
             ansiColors.red(
-              `web ! ${src} failed to execute No "tests.json" file was generated. Check ${reportDest}/error.log for more info`
+              ansiColors.inverse(
+                `python: ${src} errored with: ${e.name}. Check error logs for more info`
+              )
             )
           );
           this.bddTestIsNowDone(src, -1);
-          close();
+          statusMessagePretty(-1, src, "python");
+          reject(e);
+        });
+      }).finally(() => {
+        portsToUse.forEach(port => {
+          this.ports[port] = "";
         });
-
-        // page.on("console", (log: ConsoleMessage) => {});
-
-        await page.goto(`file://${`${destFolder}.html`}`, {});
-
-        await page
-          .evaluate(
-            `
-import('${d}').then(async (x) => {
-  try {
-    return await (await x.default).receiveTestResourceConfig(${webArgz})
-  } catch (e) {
-    console.log("web run failure", e.toString())
-  }
-})
-`
-          )
-          .then(async ({ fails, failed, features }: IFinalResults) => {
-            statusMessagePretty(fails, src, "web");
-            this.bddTestIsNowDone(src, fails);
-            // close();
-          })
-          .catch((e) => {
-            console.log(ansiC.red(ansiC.inverse(e.stack)));
-
-            console.log(
-              ansiC.red(
-                ansiC.inverse(
-                  `web ! ${src} failed to execute. No "tests.json" file was generated. Check logs for more info`
-                )
-              )
-            );
-            this.bddTestIsNowDone(src, -1);
-          })
-          .finally(() => {
-            // process.exit(-1);
-            close();
-          });
-
-        return page;
       });
-  };
-
-  receiveFeaturesV2 = (
-    reportDest: string,
-    srcTest: string,
-    platform: IRunTime
-  ) => {
-    const featureDestination = path.resolve(
-      process.cwd(),
-      "reports",
-      "features",
-      "strings",
-      srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      pythonPromise,
+      command,
+      "bdd-test",
+      src,
+      "python"
     );
+  };
 
-    // Read and parse the test report
-    const testReportPath = `${reportDest}/tests.json`;
-    if (!fs.existsSync(testReportPath)) {
-      console.error(`tests.json not found at: ${testReportPath}`);
-      return;
-    }
-
-    const testReport = JSON.parse(fs.readFileSync(testReportPath, "utf8"));
+  launchGolang = async (src: string, dest: string) => {
+    const processId = `golang-${src}-${Date.now()}`;
+    const command = `golang test: ${src}`;
 
-    // Add full path information to each test
-    if (testReport.tests) {
-      testReport.tests.forEach((test) => {
-        // Add the full path to each test
-        test.fullPath = path.resolve(process.cwd(), srcTest);
-      });
-    }
-
-    // Add full path to the report itself
-    testReport.fullPath = path.resolve(process.cwd(), srcTest);
-
-    // Write the modified report back
-    fs.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
-
-    testReport.features
-      .reduce(async (mm, featureStringKey) => {
-        const accum = await mm;
-
-        const isUrl = isValidUrl(featureStringKey);
-
-        if (isUrl) {
-          const u = new URL(featureStringKey);
-
-          if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/testeranto/features/internal/${path.relative(
-              process.cwd(),
-              u.pathname
-            )}`;
-
-            // await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
-
-            // try {
-            //   await fs.unlinkSync(newPath);
-            //   // console.log(`Removed existing link at ${newPath}`);
-            // } catch (error) {
-            //   if (error.code !== "ENOENT") {
-            //     // throw error;
-            //   }
-            // }
-
-            // fs.symlink(u.pathname, newPath, (err) => {
-            //   if (err) {
-            //     // console.error("Error creating symlink:", err);
-            //   } else {
-            //     // console.log("Symlink created successfully");
-            //   }
-            // });
-            accum.files.push(u.pathname);
-          } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/testeranto/features/external/${
-              u.hostname
-            }${u.pathname}`;
-
-            const body = await this.configs.featureIngestor(featureStringKey);
-
-            writeFileAndCreateDir(newPath, body);
-            accum.files.push(newPath);
-          }
-        } else {
-          await fs.promises.mkdir(path.dirname(featureDestination), {
-            recursive: true,
-          });
+    const golangPromise = (async () => {
+      this.bddTestIsRunning(src);
 
-          accum.strings.push(featureStringKey);
-        }
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/golang`;
 
-        return accum;
-      }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-      .then(({ files, strings }: { files: string[]; strings: string[] }) => {
-        // Markdown files must be referenced in the prompt but string style features are already present in the tests.json file
+      let testResources = "";
 
-        fs.writeFileSync(
-          `testeranto/reports/${this.name}/${srcTest
-            .split(".")
-            .slice(0, -1)
-            .join(".")}/${platform}/featurePrompt.txt`,
-          files
-            .map((f) => {
-              return `/read ${f}`;
-            })
-            .join("\n")
+      const testConfig = this.configs.tests.find((t) => t[0] === src);
+      if (!testConfig) {
+        console.log(
+          ansiColors.inverse(
+            `golang: missing test config! Exiting ungracefully for '${src}'`
+          )
         );
-      });
-
-    // const f: Record<string, string> = {};
-
-    testReport.givens.forEach((g) => {
-      if (g.failed === true) {
-        this.summary[srcTest].failingFeatures[g.key] = g.features;
+        process.exit(-1);
       }
-    });
 
-    // this.summary[srcTest].failingFeatures = f;
-    this.writeBigBoard();
-  };
+      const testConfigResource = testConfig[2];
+      const portsToUse: string[] = [];
 
-  requestHandler(req: http.IncomingMessage, res: http.ServerResponse) {
-    // Parse the URL
-    const parsedUrl = url.parse(req.url || "/");
-    let pathname = parsedUrl.pathname || "/";
-
-    // Handle root path
-    if (pathname === "/") {
-      pathname = "/index.html";
-    }
-
-    // Remove leading slash
-    let filePath = pathname.substring(1);
-
-    // Determine which directory to serve from
-    if (filePath.startsWith("reports/")) {
-      // Serve from reports directory
-      filePath = `testeranto/${filePath}`;
-    } else if (filePath.startsWith("metafiles/")) {
-      // Serve from metafiles directory
-      filePath = `testeranto/${filePath}`;
-    } else if (filePath === "projects.json") {
-      // Serve projects.json
-      filePath = `testeranto/${filePath}`;
-    } else {
-      // For frontend assets, try multiple possible locations
-      // First, try the dist directory
-      const possiblePaths = [
-        `dist/${filePath}`,
-        `testeranto/dist/${filePath}`,
-        `../dist/${filePath}`,
-        `./${filePath}`,
-      ];
-
-      // Find the first existing file
-      let foundPath = null;
-      for (const possiblePath of possiblePaths) {
-        if (fs.existsSync(possiblePath)) {
-          foundPath = possiblePath;
-          break;
-        }
-      }
+      if (testConfigResource.ports === 0) {
+        testResources = JSON.stringify({
+          scheduled: true,
+          name: src,
+          ports: portsToUse,
+          fs: reportDest,
+          browserWSEndpoint: this.browser.wsEndpoint(),
+        });
+      } else if (testConfigResource.ports > 0) {
+        const openPorts = Object.entries(this.ports).filter(
+          ([, status]) => status === ""
+        );
 
-      if (foundPath) {
-        filePath = foundPath;
-      } else {
-        // If no file found, serve index.html for SPA routing
-        const indexPath = this.findIndexHtml();
-        if (indexPath) {
-          fs.readFile(indexPath, (err, data) => {
-            if (err) {
-              res.writeHead(404, { "Content-Type": "text/plain" });
-              res.end("404 Not Found");
-              return;
-            }
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(data);
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
+            this.ports[openPorts[i][0]] = src;
+          }
+
+          testResources = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: portsToUse,
+            fs: reportDest,
+            browserWSEndpoint: this.browser.wsEndpoint(),
           });
-          return;
         } else {
-          res.writeHead(404, { "Content-Type": "text/plain" });
-          res.end("404 Not Found");
+          console.log(
+            ansiColors.red(
+              `golang: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
+            )
+          );
+          this.queue.push(src);
           return;
         }
+      } else {
+        console.error("negative port makes no sense", src);
+        process.exit(-1);
       }
-    }
-
-    // Check if file exists
-    fs.exists(filePath, (exists) => {
-      if (!exists) {
-        // For SPA routing, serve index.html if the path looks like a route
-        if (!pathname.includes(".") && pathname !== "/") {
-          const indexPath = this.findIndexHtml();
-          if (indexPath) {
-            fs.readFile(indexPath, (err, data) => {
-              if (err) {
-                res.writeHead(404, { "Content-Type": "text/plain" });
-                res.end("404 Not Found");
-                return;
-              }
-              res.writeHead(200, { "Content-Type": "text/html" });
-              res.end(data);
-            });
-            return;
-          } else {
-            // Serve a simple message if index.html is not found
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(`
-              <html>
-                <body>
-                  <h1>Testeranto is running</h1>
-                  <p>Frontend files are not built yet. Run 'npm run build' to build the frontend.</p>
-                </body>
-              </html>
-            `);
-            return;
-          }
-        }
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end("404 Not Found");
-        return;
-      }
-
-      // Read and serve the file
-      fs.readFile(filePath, (err, data) => {
-        if (err) {
-          res.writeHead(500, { "Content-Type": "text/plain" });
-          res.end("500 Internal Server Error");
-          return;
-        }
 
-        // Get MIME type
-        const mimeType = mime.lookup(filePath) || "application/octet-stream";
-        res.writeHead(200, { "Content-Type": mimeType });
-        res.end(data);
-      });
-    });
-  }
-
-  findIndexHtml(): string | null {
-    const possiblePaths = [
-      "dist/index.html",
-      "testeranto/dist/index.html",
-      "../dist/index.html",
-      "./index.html",
-    ];
-
-    for (const path of possiblePaths) {
-      if (fs.existsSync(path)) {
-        return path;
-      }
-    }
-    return null;
-  }
-
-  broadcast(message: any) {
-    const data =
-      typeof message === "string" ? message : JSON.stringify(message);
-    this.clients.forEach((client) => {
-      if (client.readyState === 1) {
-        // WebSocket.OPEN
-        client.send(data);
-      }
-    });
-  }
-
-  checkQueue() {
-    const x = this.queue.pop();
-    if (!x) {
-      ansiC.inverse(`The following queue is empty`);
-      return;
-    }
-    const test = this.configs.tests.find((t) => t[0] === x);
-    if (!test) throw `test is undefined ${x}`;
-
-    // const [src, runtime, ...xx]: [string, IRunTime, ...any] = test;
-    this.launchers[test[0]]();
-  }
-
-  checkForShutdown = () => {
-    // console.log(ansiC.inverse(JSON.stringify(this.summary, null, 2)));
-
-    this.checkQueue();
-
-    console.log(
-      ansiC.inverse(
-        `The following jobs are awaiting resources: ${JSON.stringify(
-          this.queue
-        )}`
-      )
-    );
-    console.log(
-      ansiC.inverse(`The status of ports: ${JSON.stringify(this.ports)}`)
-    );
+      // Compile the Go test first
+      const buildDir = path.dirname(dest);
+      const binaryName = path.basename(dest, '.go');
+      const binaryPath = path.join(buildDir, binaryName);
+      
+      const logs = createLogStreams(reportDest, "golang");
 
-    this.writeBigBoard();
+      // First, compile the Go program
+      const compileProcess = spawn("go", ["build", "-o", binaryPath, dest]);
+      
+      return new Promise<void>((resolve, reject) => {
+        compileProcess.stdout?.on("data", (data) => {
+          logs.stdout?.write(data);
+        });
 
-    if (this.mode === "dev") return;
+        compileProcess.stderr?.on("data", (data) => {
+          logs.stderr?.write(data);
+        });
 
-    let inflight = false;
+        compileProcess.on("close", (compileCode) => {
+          if (compileCode !== 0) {
+            console.log(
+              ansiColors.red(
+                `golang ! ${src} failed to compile. Check ${reportDest}/stderr.log for more info`
+              )
+            );
+            this.bddTestIsNowDone(src, compileCode || -1);
+            statusMessagePretty(compileCode || -1, src, "golang");
+            reject(new Error(`Compilation failed with code ${compileCode}`));
+            return;
+          }
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].prompt === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 prompt ${k}`)));
-        inflight = true;
-      }
-    });
+          // Now run the compiled binary
+          const child = spawn(binaryPath, [testResources], {
+            stdio: ["pipe", "pipe", "pipe"],
+          });
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].runTimeErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 runTimeError ${k}`)));
-        inflight = true;
-      }
-    });
+          child.stdout?.on("data", (data) => {
+            logs.stdout?.write(data);
+          });
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].staticErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 staticErrors ${k}`)));
-        inflight = true;
-      }
-    });
+          child.stderr?.on("data", (data) => {
+            logs.stderr?.write(data);
+          });
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].typeErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 typeErrors ${k}`)));
-        inflight = true;
-      }
-    });
+          child.on("close", (code) => {
+            const exitCode = code === null ? -1 : code;
+            if (exitCode < 0) {
+              logs.writeExitCode(
+                exitCode,
+                new Error("Process crashed or was terminated")
+              );
+            } else {
+              logs.writeExitCode(exitCode);
+            }
+            logs.closeAll();
 
-    this.writeBigBoard();
+            if (exitCode === 0) {
+              this.bddTestIsNowDone(src, 0);
+              statusMessagePretty(0, src, "golang");
+              resolve();
+            } else {
+              console.log(
+                ansiColors.red(
+                  `golang ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
+                )
+              );
+              this.bddTestIsNowDone(src, exitCode);
+              statusMessagePretty(exitCode, src, "golang");
+              reject(new Error(`Process exited with code ${exitCode}`));
+            }
+          });
 
-    if (!inflight) {
-      if (this.browser) {
-        if (this.browser) {
-          this.browser.disconnect().then(() => {
+          child.on("error", (e) => {
             console.log(
-              ansiC.inverse(`${this.name} has been tested. Goodbye.`)
+              ansiColors.red(
+                ansiColors.inverse(
+                  `golang: ${src} errored with: ${e.name}. Check error logs for more info`
+                )
+              )
             );
-            process.exit();
+            this.bddTestIsNowDone(src, -1);
+            statusMessagePretty(-1, src, "golang");
+            reject(e);
           });
-        }
-      }
-    }
+        });
+
+        compileProcess.on("error", (e) => {
+          console.log(
+            ansiColors.red(
+              ansiColors.inverse(
+                `golang: ${src} compilation errored with: ${e.name}. Check error logs for more info`
+              )
+            )
+          );
+          this.bddTestIsNowDone(src, -1);
+          statusMessagePretty(-1, src, "golang");
+          reject(e);
+        });
+      }).finally(() => {
+        portsToUse.forEach(port => {
+          this.ports[port] = "";
+        });
+      });
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      golangPromise,
+      command,
+      "bdd-test",
+      src,
+      "golang"
+    );
   };
 }