testeranto 0.200.1 → 0.203.0

package/src/PM/main.ts

@@ -3,1174 +3,78 @@
 /* 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,
+  IRunTime,
 } from "../lib/index.js";
-import { getRunnables } from "../utils";
-import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-import { Sidecar } from "../lib/Sidecar.js";
+import { webEvaluator } from "../utils";
 import { Queue } from "../utils/queue.js";
 
-import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+import { createLogStreams, statusMessagePretty } from "./utils.js";
+import { PM_WithHelpo } from "./PM_WithHelpo.js";
+import path from "node:path";
 
-type IOutputs = Record<
-  string,
-  {
-    entryPoint: string;
-    inputs: Record<string, string>;
-  }
->;
-
-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);
-
-    fileStream.on("data", (data) => {
-      hash.update(data);
-    });
-
-    fileStream.on("end", () => {
-      const fileHash = hash.digest("hex");
-      resolve(fileHash);
-    });
-
-    fileStream.on("error", (error) => {
-      reject(`Error reading file: ${error.message}`);
-    });
-  });
-}
-
-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 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;
-  }
-}
-
-// 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);
-}
-
-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(),
-              });
-
-              // 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(),
-              });
-
-              // Initialize logs for this process
-              this.processLogs.set(processId, []);
-
-              // Broadcast process started
-              this.broadcast({
-                type: "processStarted",
-                processId,
-                command: message.command,
-                timestamp: new Date().toISOString(),
-                logs: [],
-              });
-
-              // 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(),
-                });
-              });
-
-              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(),
-                });
-              });
-
-              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(),
-                });
-              });
-
-              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(),
-                });
-              });
-            } 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 {
-              console.log(
-                "Cannot write to stdin - process not found or no stdin:",
-                {
-                  processExists: !!childProcess,
-                  stdinExists: childProcess?.stdin ? true : false,
-                }
-              );
-            }
-          } 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)];
-          }
-        });
-      }
-    });
-
-    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);
-            }
-          }
-        );
-
-        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);
-              })
-            );
-          }
-        }
-      }
-    );
-
-    // 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);
-      }
-
-      const entrypoint = outputs[k].entryPoint;
-
-      if (entrypoint) {
-        const changeDigest = await filesHash(addableFiles);
-
-        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);
-        }
-      }
-    });
-  }
-
-  launchPure = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`pure < ${src}`)));
+export class PM_Main extends PM_WithHelpo {
+  private async setupTestEnvironment(
+    src: string,
+    runtime: IRunTime
+  ): Promise<{
+    reportDest: string;
+    testConfig: any;
+    testConfigResource: any;
+    portsToUse: string[];
+    testResources: string;
+  }> {
     this.bddTestIsRunning(src);
 
     const reportDest = `testeranto/reports/${this.name}/${src
       .split(".")
       .slice(0, -1)
-      .join(".")}/pure`;
+      .join(".")}/${runtime}`;
 
     if (!fs.existsSync(reportDest)) {
       fs.mkdirSync(reportDest, { recursive: true });
     }
 
-    const destFolder = dest.replace(".mjs", "");
-
-    let argz = "";
-
-    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(),
-      });
-    } 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(
-          ansiC.inverse(
-            `${src} 1 errored with: ${e3}. Check logs for more info`
-          )
-        )
-      );
-
-      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
-      }
-    }
-  };
-
-  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;
-    });
-
+    const testConfig = this.configs.tests.find((t) => t[0] === src);
     if (!testConfig) {
       console.log(
         ansiC.inverse(`missing test config! Exiting ungracefully for '${src}'`)
       );
       process.exit(-1);
     }
-    const testConfigResource = testConfig[2];
 
+    const testConfigResource = testConfig[2];
     const portsToUse: string[] = [];
+    let testResources = "";
+
     if (testConfigResource.ports === 0) {
-      const t: ITTestResourceConfiguration = {
+      testResources = JSON.stringify({
         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 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]); // Convert string port to number
-
-          this.ports[openPorts[i][0]] = src; // port is now claimed
+          portsToUse.push(openPorts[i][0]);
+          this.ports[openPorts[i][0]] = src;
         }
 
         testResources = JSON.stringify({
@@ -1183,95 +87,66 @@ export class PM_Main extends PM_WithEslintAndTsc {
       } 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`
+            `${runtime}: 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 [Math.random(), argz]; // Add this return
+        throw new Error("No ports available");
       }
     } 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]);
-
-        for (let b = 0; b < buffer.length + 1; b++) {
-          const c = buffer.slice(0, b);
-          let d;
-          try {
-            d = JSON.parse(c.toString());
+    return {
+      reportDest,
+      testConfig,
+      testConfigResource,
+      portsToUse,
+      testResources,
+    };
+  }
 
-            queue.enqueue(d);
-            buffer = buffer.slice(b, buffer.length + 1);
-            b = 0;
-          } catch (e) {
-            // b++;
-          }
-        }
+  private cleanupPorts(portsToUse: string[]) {
+    portsToUse.forEach((port) => {
+      this.ports[port] = "";
+    });
+  }
 
-        while (queue.size() > 0) {
-          const message = queue.dequeue();
+  private createIpcServer(
+    onData: (data: Buffer) => void,
+    ipcfile: string
+  ): Promise<net.Server> {
+    return new Promise((resolve, reject) => {
+      const server = net.createServer((socket) => {
+        socket.on("data", onData);
+      });
 
-          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],
-                    })
-                  );
-                }
-              }
-            });
-          }
-        }
+      server.listen(ipcfile, (err) => {
+        if (err) reject(err);
+        else resolve(server);
       });
-    });
 
-    const logs = createLogStreams(reportDest, "node");
+      server.on("error", reject);
+    });
+  }
 
-    server.listen(ipcfile, () => {
-      // Only handle stdout/stderr for node runtime
+  private handleChildProcess(
+    child: ChildProcess,
+    logs: LogStreams,
+    reportDest: string,
+    src: string,
+    runtime: IRunTime
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
       child.stdout?.on("data", (data) => {
-        logs.stdout?.write(data); // Add null check
+        logs.stdout?.write(data);
       });
 
       child.stderr?.on("data", (data) => {
-        logs.stderr?.write(data); // Add null check
+        logs.stderr?.write(data);
       });
-      child.on("error", (err) => {});
+
       child.on("close", (code) => {
         const exitCode = code === null ? -1 : code;
         if (exitCode < 0) {
@@ -1283,45 +158,24 @@ export class PM_Main extends PM_WithEslintAndTsc {
           logs.writeExitCode(exitCode);
         }
         logs.closeAll();
-        server.close();
-
-        if (!files[src]) {
-          files[src] = new Set();
-        }
 
-        if (exitCode === 255) {
+        if (exitCode === 0) {
+          this.bddTestIsNowDone(src, 0);
+          statusMessagePretty(0, src, runtime);
+          resolve();
+        } else {
           console.log(
             ansiColors.red(
-              `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/stderr.log for more info`
+              `${runtime} ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
             )
           );
-          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");
+          statusMessagePretty(exitCode, src, runtime);
+          reject(new Error(`Process exited with code ${exitCode}`));
         }
-
-        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");
-
-        haltReturns = true;
-
         console.log(
           ansiC.red(
             ansiC.inverse(
@@ -1330,898 +184,798 @@ export class PM_Main extends PM_WithEslintAndTsc {
           )
         );
         this.bddTestIsNowDone(src, -1);
-        statusMessagePretty(-1, src, "node");
+        statusMessagePretty(-1, src, runtime);
+        reject(e);
       });
     });
-  };
-
-  launchWebSideCar = async (
-    testConfig: ITestTypes
-  ): Promise<[number, Page]> => {
-    const src = testConfig[0];
-    const dest = src.split(".").slice(0, -1).join(".");
-    // const d = dest + ".mjs";
+  }
 
-    const destFolder = dest.replace(".mjs", "");
+  launchPure = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`pure < ${src}`)));
 
-    console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
+    const processId = `pure-${src}-${Date.now()}`;
+    const command = `pure test: ${src}`;
 
-    // const fileStreams2: fs.WriteStream[] = [];
-    // const doneFileStream2: Promise<any>[] = [];
+    // Create the promise
+    const purePromise = (async () => {
+      this.bddTestIsRunning(src);
 
-    const logs = createLogStreams(dest, "web");
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/pure`;
 
-    return new Promise((res, rej) => {
-      this.browser
-        .newPage()
-        .then(async (page) => {
-          this.mapping().forEach(async ([command, func]) => {
-            page.exposeFunction(command, func);
-          });
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-          const close = () => {
-            if (!files[src]) {
-              files[src] = new Set();
-            }
-            // files[src].add(filepath);
+      const destFolder = dest.replace(".mjs", "");
 
-            // fs.writeFileSync(
-            //   destFolder + "/manifest.json",
-            //   JSON.stringify(Array.from(files[src]))
-            // );
+      let argz = "";
 
-            delete files[src];
+      const testConfig = this.configs.tests.find((t) => {
+        return t[0] === src;
+      });
 
-            Promise.all(screenshots[src] || []).then(() => {
-              delete screenshots[src];
-              page.close();
-            });
-          };
+      if (!testConfig) {
+        console.log(
+          ansiC.inverse("missing test config! Exiting ungracefully!")
+        );
+        process.exit(-1);
+      }
+      const testConfigResource = testConfig[2];
 
-          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();
-          });
+      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 === ""
+        );
 
-          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;
-            }
-          });
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
 
-          await page.goto(`file://${`${destFolder}.html`}`, {});
+            this.ports[openPorts[i][0]] = src; // port is now claimed
+          }
 
-          const webArgz = JSON.stringify({
-            name: dest,
-            ports: [].toString(),
-            fs: dest,
+          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 d = `${dest}?cacheBust=${Date.now()}`;
+      const builtfile = dest;
 
-          const evaluation = `
-    import('${d}').then(async (x) => {
+      const logs = createLogStreams(reportDest, "pure");
 
       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);
+        await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+          return module.default
+            .then((defaultModule) => {
+              return defaultModule
+                .receiveTestResourceConfig(argz)
+                .then(async (results: IFinalResults) => {
+                  // Ensure the test results are properly processed
+                  // The receiveTestResourceConfig should handle creating tests.json
+                  statusMessagePretty(results.fails, src, "pure");
+                  this.bddTestIsNowDone(src, results.fails);
+                  return results.fails;
+                });
             })
-            .catch((e) => {
+            .catch((e2) => {
               console.log(
-                ansiC.red(
-                  ansiC.inverse(`launchWebSidecar - ${src} errored with: ${e}`)
+                ansiColors.red(
+                  `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
                 )
               );
-            })
-            .finally(() => {
-              this.bddTestIsNowDone(src, -1);
-              close();
-            });
 
-          return page;
-
-          // return page;
-        })
-        .then(async (page) => {
-          await page.goto(`file://${`${dest}.html`}`, {});
+              // Create a minimal tests.json even on failure
+              const testsJsonPath = `${reportDest}/tests.json`;
+              if (!fs.existsSync(testsJsonPath)) {
+                fs.writeFileSync(
+                  testsJsonPath,
+                  JSON.stringify(
+                    {
+                      tests: [],
+                      features: [],
+                      givens: [],
+                      fullPath: src,
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
 
-          res([Math.random(), page]);
+              logs.exit.write(e2.stack);
+              logs.exit.write(-1);
+              this.bddTestIsNowDone(src, -1);
+              statusMessagePretty(-1, src, "pure");
+              throw e2;
+            });
         });
-    });
-  };
-
-  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");
+      } catch (e3) {
+        // Create a minimal tests.json even on uncaught errors
+        const testsJsonPath = `${reportDest}/tests.json`;
+        if (!fs.existsSync(testsJsonPath)) {
+          fs.writeFileSync(
+            testsJsonPath,
+            JSON.stringify(
+              {
+                tests: [],
+                features: [],
+                givens: [],
+                fullPath: src,
+              },
+              null,
+              2
+            )
+          );
+        }
 
-    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 === ""
-      );
+        logs.writeExitCode(-1, e3);
+        console.log(
+          ansiC.red(
+            ansiC.inverse(
+              `${src} 1 errored with: ${e3}. Check logs for more info`
+            )
+          )
+        );
 
-      if (openPorts.length >= testReq.ports) {
-        for (let i = 0; i < testReq.ports; i++) {
-          portsToUse.push(Number(openPorts[i][0])); // Convert string port to number
+        logs.exit.write(e3.stack);
+        logs.exit.write("-1");
+        this.bddTestIsNowDone(src, -1);
+        statusMessagePretty(-1, src, "pure");
+        throw e3;
+      } finally {
+        // Generate prompt files for Pure tests
+        await this.generatePromptFiles(reportDest, src);
 
-          this.ports[openPorts[i][0]] = src; // port is now closed
+        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"
+    );
+  };
 
-        argz.ports = portsToUse;
+  launchNode = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`node < ${src}`)));
 
-        const builtfile = destFolder + ".mjs";
+    const processId = `node-${src}-${Date.now()}`;
+    const command = `node test: ${src}`;
 
-        let haltReturns = false;
+    const nodePromise = (async () => {
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "node");
 
-        let buffer: Buffer<ArrayBufferLike> = new Buffer("");
+        const builtfile = dest;
+        const ipcfile = "/tmp/tpipe_" + Math.random();
+        const logs = createLogStreams(reportDest, "node");
 
-        const server = net.createServer((socket) => {
-          socket.on("data", (data) => {
-            buffer = Buffer.concat([buffer, data]);
+        let buffer = Buffer.from("");
+        const queue = new Queue<string[]>();
 
-            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());
+        const onData = (data: Buffer) => {
+          buffer = Buffer.concat([buffer, data]);
 
-                messages.push(d);
-                buffer = buffer.slice(b, buffer.length + 1);
-                b = 0;
-              } catch (e) {
-                // b++;
-              }
+          // Process complete JSON messages
+          for (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            try {
+              const d = JSON.parse(c.toString());
+              queue.enqueue(d);
+              buffer = buffer.slice(b);
+              b = 0;
+            } catch (e) {
+              // Continue processing
             }
+          }
 
-            messages.forEach(async (payload) => {
+          // Process messages
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
               this.mapping().forEach(async ([command, func]) => {
-                if (payload[0] === command) {
-                  const x = payload.slice(1, -1);
-                  const r = await this[command](...x);
-
-                  if (!haltReturns) {
+                if (message[0] === command) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
                     child.send(
                       JSON.stringify({
-                        payload: r,
-                        key: payload[payload.length - 1],
+                        payload: result,
+                        key: message[message.length - 1],
                       })
                     );
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
                   }
                 }
               });
-            });
-          });
-        });
+            }
+          }
+        };
 
-        const child = spawn("node", [builtfile, JSON.stringify(argz)], {
+        const server = await this.createIpcServer(onData, ipcfile);
+        const child = spawn("node", [builtfile, testResources, ipcfile], {
           stdio: ["pipe", "pipe", "pipe", "ipc"],
-          // silent: true
         });
 
-        const p = "/tmp/tpipe" + Math.random();
-
-        server.listen(p, () => {
-          child.on("close", (code) => {
-            server.close();
-            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) => {
-            if (fs.existsSync(p)) {
-              fs.rmSync(p);
-            }
+        try {
+          await this.handleChildProcess(child, logs, reportDest, src, "node");
 
-            haltReturns = true;
+          // Generate prompt files for Node tests
+          await this.generatePromptFiles(reportDest, src);
+        } finally {
+          server.close();
+          this.cleanupPorts(portsToUse);
+        }
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
+      }
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      nodePromise,
+      command,
+      "bdd-test",
+      src,
+      "node"
+    );
+  };
 
-            console.log(
-              ansiC.red(
-                ansiC.inverse(
-                  `launchNodeSideCar - ${src} errored with: ${e.name}. Check logs for more info`
-                )
-              )
-            );
-            logs.error?.write(e.toString() + "\n");
-            // this.bddTestIsNowDone(src, -1);
-            // statusMessagePretty(-1, src);
-          });
-        });
+  launchWeb = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`web < ${src}`)));
 
-        child.send({ path: p });
+    const processId = `web-${src}-${Date.now()}`;
+    const command = `web test: ${src}`;
 
-        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`
-          )
-        );
+    // Create the promise
+    const webPromise = (async () => {
+      this.bddTestIsRunning(src);
 
-        this.queue.push(sidecar[0]);
-        return [Math.random(), argz];
+      const reportDest = `testeranto/reports/${this.name}/${src
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/web`;
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
       }
-    } else {
-      console.error("negative port makes no sense", sidecar[0]);
-      process.exit(-1);
-    }
-  };
 
-  stopPureSideCar = async (uid: number) => {
-    console.log(ansiC.green(ansiC.inverse(`stopPureSideCar ${uid}`)));
-    await this.sidecars[uid].shutdown();
-    return;
-  };
+      const destFolder = dest.replace(".mjs", "");
 
-  launchPureSideCar = async (
-    sidecar: ITestTypes
-  ): Promise<[number, ITTestResourceConfiguration]> => {
-    console.log(ansiC.green(ansiC.inverse(`launchPureSideCar ${sidecar[0]}`)));
+      const webArgz = JSON.stringify({
+        name: src,
+        ports: [].toString(),
+        fs: reportDest,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+      });
 
-    const r = Math.random();
+      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;
+              }
+            });
 
-    const dest =
-      process.cwd() + `/testeranto/bundles/pure/${this.name}/${sidecar[0]}`;
-    const builtfile = dest.split(".").slice(0, -1).concat("mjs").join(".");
+            page.on("close", () => {
+              logs.writeExitCode(0);
+              logs.closeAll();
+            });
 
-    const destFolder = dest.replace(".mjs", "");
+            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);
+              }
+            });
 
-    let argz: ITTestResourceConfiguration;
+            return page;
+          })
+          .then(async (page) => {
+            const close = () => {
+              if (!files[src]) {
+                files[src] = new Set();
+              }
 
-    const z = sidecar[2];
-    const testConfigResource: { ports: number } = sidecar[2];
-    const src = sidecar[0];
+              delete files[src];
 
-    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]));
+              Promise.all(screenshots[src] || []).then(() => {
+                delete screenshots[src];
+                page.close();
+              });
+            };
 
-          this.ports[openPorts[i][0]] = src; // port is now claimed
-        }
+            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);
+            });
 
-        argz = {
-          // scheduled: true,
-          name: src,
-          // ports: [3333],
-          ports: portsToUse,
-          fs: ".",
-          browserWSEndpoint: this.browser.wsEndpoint(),
-        };
-      } else {
-        this.queue.push(src);
-        // return;
-      }
-    } else {
-      console.error("negative port makes no sense", src);
-      process.exit(-1);
-    }
+            await page.goto(`file://${`${destFolder}.html`}`, {});
 
-    // const builtfile = dest + ".mjs";
+            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`
+                    )
+                  )
+                );
 
-    await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-      if (!this.pureSidecars) this.pureSidecars = {};
-      this.pureSidecars[r] = module.default;
-      this.pureSidecars[r].start(argz);
-    });
+                // Create a minimal tests.json even on failure
+                const testsJsonPath = `${reportDest}/tests.json`;
+                if (!fs.existsSync(testsJsonPath)) {
+                  fs.writeFileSync(
+                    testsJsonPath,
+                    JSON.stringify(
+                      {
+                        tests: [],
+                        features: [],
+                        givens: [],
+                        fullPath: src,
+                      },
+                      null,
+                      2
+                    )
+                  );
+                }
 
-    return [r, argz];
-    // for (let i = 0; i <= portsToUse.length; i++) {
-    //   if (portsToUse[i]) {
-    //     this.ports[portsToUse[i]] = "true"; //port is open again
-    //   }
-    // }
+                this.bddTestIsNowDone(src, -1);
+                reject(e);
+              })
+              .finally(async () => {
+                // Generate prompt files for Web tests
+                await this.generatePromptFiles(reportDest, src);
+                close();
+              });
+          })
+          .catch((error) => {
+            reject(error);
+          });
+      });
+    })();
+
+    // Add to process manager
+    this.addPromiseProcess(
+      processId,
+      webPromise,
+      command,
+      "bdd-test",
+      src,
+      "web"
+    );
   };
 
-  launchPitono = async (src: string, dest: string) => {
-    console.log(ansiC.green(ansiC.inverse(`pitono < ${src}`)));
-    this.bddTestIsRunning(src);
+  launchPython = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`python < ${src}`)));
 
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/pitono`;
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
+    const processId = `python-${src}-${Date.now()}`;
+    const command = `python test: ${src}`;
 
-    const logs = createLogStreams(reportDest, "node"); // Use node-style logs for pitono
+    const pythonPromise = (async () => {
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "python");
 
-    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);
+        // Determine Python command
+        const venvPython = `./venv/bin/python3`;
+        const pythonCommand = fs.existsSync(venvPython)
+          ? venvPython
+          : "python3";
 
-    const reportDest = `testeranto/reports/${this.name}/${src
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/web`;
-    if (!fs.existsSync(reportDest)) {
-      fs.mkdirSync(reportDest, { recursive: true });
-    }
+        const ipcfile = "/tmp/tpipe_python_" + Math.random();
+        const child = spawn(pythonCommand, [src, testResources, ipcfile], {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+        });
 
-    const destFolder = dest.replace(".mjs", "");
+        // IPC server setup is similar to Node
+        let buffer = Buffer.from("");
+        const queue = new Queue<string[]>();
 
-    const webArgz = JSON.stringify({
-      name: src,
-      ports: [].toString(),
-      fs: reportDest,
-      browserWSEndpoint: this.browser.wsEndpoint(),
-    });
+        const onData = (data: Buffer) => {
+          buffer = Buffer.concat([buffer, data]);
 
-    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 (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            try {
+              const d = JSON.parse(c.toString());
+              queue.enqueue(d);
+              buffer = buffer.slice(b);
+              b = 0;
+            } catch (e) {
+              // Continue processing
+            }
           }
-        });
 
-        page.on("close", () => {
-          logs.writeExitCode(0); // Web tests exit with 0 unless there's an error
-          logs.closeAll();
-          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);
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
+              this.mapping().forEach(async ([command, func]) => {
+                if (message[0] === command) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
+                    child.send(
+                      JSON.stringify({
+                        payload: result,
+                        key: message[message.length - 1],
+                      })
+                    );
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
+                  }
+                }
+              });
+            }
           }
-        });
+        };
 
-        return page;
-      })
-      .then(async (page) => {
-        const close = () => {
-          if (!files[src]) {
-            files[src] = new Set();
-          }
-          // files[t].add(filepath);
+        const server = await this.createIpcServer(onData, ipcfile);
 
-          // fs.writeFileSync(
-          //   destFolder + "/manifest.json",
-          //   JSON.stringify(Array.from(files[src]))
-          // );
-          delete files[src];
+        try {
+          await this.handleChildProcess(child, logs, reportDest, src, "python");
 
-          Promise.all(screenshots[src] || []).then(() => {
-            delete screenshots[src];
-            page.close();
-          });
+          // Generate prompt files for Python tests
+          await this.generatePromptFiles(reportDest, src);
+        } finally {
+          server.close();
+          this.cleanupPorts(portsToUse);
+        }
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
+      }
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      pythonPromise,
+      command,
+      "bdd-test",
+      src,
+      "python"
+    );
+  };
 
-          return;
-        };
+  launchGolang = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`goland < ${src}`)));
 
-        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();
-        });
+    const processId = `golang-${src}-${Date.now()}`;
+    const command = `golang test: ${src}`;
 
-        // page.on("console", (log: ConsoleMessage) => {});
+    const golangPromise = (async () => {
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "golang");
 
-        await page.goto(`file://${`${destFolder}.html`}`, {});
+        const logs = createLogStreams(reportDest, "golang");
 
-        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)));
+        // Create IPC file path
+        const ipcfile =
+          "/tmp/tpipe_golang_" + Math.random().toString(36).substring(2);
 
-            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();
-          });
+        let buffer = Buffer.from("");
+        const queue = new Queue<string[]>();
 
-        return page;
-      });
-  };
+        const onData = (data: Buffer) => {
+          buffer = Buffer.concat([buffer, data]);
 
-  receiveFeaturesV2 = (
-    reportDest: string,
-    srcTest: string,
-    platform: IRunTime
-  ) => {
-    const featureDestination = path.resolve(
-      process.cwd(),
-      "reports",
-      "features",
-      "strings",
-      srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
-    );
+          // Process complete JSON messages
+          for (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            try {
+              const d = JSON.parse(c.toString());
+              queue.enqueue(d);
+              buffer = buffer.slice(b);
+              b = 0;
+            } catch (e) {
+              // Continue processing
+            }
+          }
 
-    // Read and parse the test report
-    const testReportPath = `${reportDest}/tests.json`;
-    if (!fs.existsSync(testReportPath)) {
-      console.error(`tests.json not found at: ${testReportPath}`);
-      return;
-    }
+          // Process messages
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
+              this.mapping().forEach(async ([command, func]) => {
+                if (message[0] === command) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
+                    // Send response back through IPC
+                    // This would need to be implemented based on your IPC protocol
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
+                  }
+                }
+              });
+            }
+          }
+        };
 
-    const testReport = JSON.parse(fs.readFileSync(testReportPath, "utf8"));
+        // Create IPC server like in launchNode
+        const server = await this.createIpcServer(onData, ipcfile);
 
-    // 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);
-      });
-    }
+        // For Go tests, we need to run from the directory containing the go.mod file
+        // Find the nearest go.mod file by walking up the directory tree
+        let currentDir = path.dirname(src);
+        let goModDir = null;
 
-    // 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);
+        while (currentDir !== path.parse(currentDir).root) {
+          if (fs.existsSync(path.join(currentDir, "go.mod"))) {
+            goModDir = currentDir;
+            break;
           }
-        } else {
-          await fs.promises.mkdir(path.dirname(featureDestination), {
-            recursive: true,
-          });
+          currentDir = path.dirname(currentDir);
+        }
 
-          accum.strings.push(featureStringKey);
+        if (!goModDir) {
+          console.error(`Could not find go.mod file for test ${src}`);
+          // Try running from the test file's directory as a fallback
+          goModDir = path.dirname(src);
+          console.error(`Falling back to: ${goModDir}`);
         }
 
-        return accum;
-      }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
+        // Get the relative path to the test file from the go.mod directory
+        const relativeTestPath = path.relative(goModDir, src);
+
+        // Run go test from the directory containing go.mod
+        const child = spawn(
+          "go",
+          ["test", "-v", "-json", "./" + path.dirname(relativeTestPath)],
+          {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+              ...process.env,
+              TEST_RESOURCES: testResources,
+              IPC_FILE: ipcfile,
+              GO111MODULE: "on",
+            },
+            cwd: goModDir,
+          }
+        );
 
-      .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
+        await this.handleChildProcess(child, logs, reportDest, src, "golang");
 
-        fs.writeFileSync(
-          `testeranto/reports/${this.name}/${srcTest
-            .split(".")
-            .slice(0, -1)
-            .join(".")}/${platform}/featurePrompt.txt`,
-          files
-            .map((f) => {
-              return `/read ${f}`;
-            })
-            .join("\n")
-        );
-      });
+        // Generate prompt files for Golang tests
+        await this.generatePromptFiles(reportDest, src);
 
-    // const f: Record<string, string> = {};
+        // Ensure tests.json exists by parsing the go test JSON output
+        await this.processGoTestOutput(reportDest, src);
 
-    testReport.givens.forEach((g) => {
-      if (g.failed === true) {
-        this.summary[srcTest].failingFeatures[g.key] = g.features;
+        // Clean up
+        server.close();
+        try {
+          fs.unlinkSync(ipcfile);
+        } catch (e) {
+          // Ignore errors during cleanup
+        }
+        this.cleanupPorts(portsToUse);
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
       }
-    });
-
-    // this.summary[srcTest].failingFeatures = f;
-    this.writeBigBoard();
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      golangPromise,
+      command,
+      "bdd-test",
+      src,
+      "golang"
+    );
   };
 
-  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";
-    }
+  private async processGoTestOutput(
+    reportDest: string,
+    src: string
+  ): Promise<void> {
+    const testsJsonPath = `${reportDest}/tests.json`;
 
-    // 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;
-        }
-      }
+    // Parse the stdout.log to extract test results from JSON output
+    const stdoutPath = `${reportDest}/stdout.log`;
+    if (fs.existsSync(stdoutPath)) {
+      try {
+        const stdoutContent = fs.readFileSync(stdoutPath, "utf-8");
+        const lines = stdoutContent.split("\n").filter((line) => line.trim());
+
+        const testResults = {
+          tests: [],
+          features: [],
+          givens: [],
+          fullPath: path.resolve(process.cwd(), src),
+        };
 
-      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;
+        // Parse each JSON line from go test output
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            if (event.Action === "pass" || event.Action === "fail") {
+              testResults.tests.push({
+                name: event.Test || event.Package,
+                status: event.Action === "pass" ? "passed" : "failed",
+                time: event.Elapsed ? `${event.Elapsed}s` : "0s",
+              });
             }
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(data);
-          });
-          return;
-        } else {
-          res.writeHead(404, { "Content-Type": "text/plain" });
-          res.end("404 Not Found");
-          return;
-        }
-      }
-    }
-
-    // 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;
+          } catch (e) {
+            // Skip non-JSON lines
           }
         }
-        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;
+        fs.writeFileSync(testsJsonPath, JSON.stringify(testResults, null, 2));
+        return;
+      } catch (error) {
+        console.error("Error processing go test output:", error);
       }
     }
-    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);
-      }
-    });
+    // Fallback: create a basic tests.json if processing fails
+    const basicTestResult = {
+      tests: [],
+      features: [],
+      givens: [],
+      fullPath: path.resolve(process.cwd(), src),
+    };
+    fs.writeFileSync(testsJsonPath, JSON.stringify(basicTestResult, null, 2));
   }
 
-  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}`;
+  private async generatePromptFiles(
+    reportDest: string,
+    src: string
+  ): Promise<void> {
+    try {
+      // Ensure the report directory exists
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
 
-    // const [src, runtime, ...xx]: [string, IRunTime, ...any] = test;
-    this.launchers[test[0]]();
-  }
+      // Create message.txt
+      const messagePath = `${reportDest}/message.txt`;
+      const messageContent = `There are 3 types of test reports.
+1) bdd (highest priority)
+2) type checker
+3) static analysis (lowest priority)
 
-  checkForShutdown = () => {
-    // console.log(ansiC.inverse(JSON.stringify(this.summary, null, 2)));
+"tests.json" is the detailed result of the bdd tests.
+if these files do not exist, then something has gone badly wrong and needs to be addressed.
 
-    this.checkQueue();
+"type_errors.txt" is the result of the type checker.
+if this file does not exist, then type check passed without errors;
 
-    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)}`)
-    );
+"lint_errors.txt" is the result of the static analysis.
+if this file does not exist, then static analysis passed without errors;
 
-    this.writeBigBoard();
+BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
+Do not add error throwing/catching to the tests themselves.`;
 
-    if (this.mode === "dev") return;
+      fs.writeFileSync(messagePath, messageContent);
 
-    let inflight = false;
+      // Create prompt.txt
+      const promptPath = `${reportDest}/prompt.txt`;
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].prompt === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 prompt ${k}`)));
-        inflight = true;
-      }
-    });
+      const promptContent = `/read node_modules/testeranto/docs/index.md
+/read node_modules/testeranto/docs/style.md
+/read node_modules/testeranto/docs/testing.ai.txt
+/read node_modules/testeranto/src/CoreTypes.ts
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].runTimeErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 runTimeError ${k}`)));
-        inflight = true;
-      }
-    });
+/read ${reportDest}/tests.json
+/read ${reportDest}/type_errors.txt
+/read ${reportDest}/lint_errors.txt
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].staticErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 staticErrors ${k}`)));
-        inflight = true;
-      }
-    });
+/read ${reportDest}/stdout.log
+/read ${reportDest}/stderr.log
+/read ${reportDest}/exit.log
+/read ${reportDest}/message.txt`;
 
-    Object.keys(this.summary).forEach((k) => {
-      if (this.summary[k].typeErrors === "?") {
-        console.log(ansiC.blue(ansiC.inverse(`🕕 typeErrors ${k}`)));
-        inflight = true;
-      }
-    });
+      fs.writeFileSync(promptPath, promptContent);
+    } catch (error) {
+      console.error(`Failed to generate prompt files for ${src}:`, error);
+    }
+  }
 
-    this.writeBigBoard();
+  private getGolangSourceFiles(src: string): string[] {
+    // Get all .go files in the same directory as the test
+    const testDir = path.dirname(src);
+    const files: string[] = [];
 
-    if (!inflight) {
-      if (this.browser) {
-        if (this.browser) {
-          this.browser.disconnect().then(() => {
-            console.log(
-              ansiC.inverse(`${this.name} has been tested. Goodbye.`)
-            );
-            process.exit();
-          });
+    try {
+      const dirContents = fs.readdirSync(testDir);
+      dirContents.forEach((file) => {
+        if (file.endsWith(".go")) {
+          files.push(path.join(testDir, file));
         }
-      }
+      });
+    } catch (error) {
+      console.error(`Error reading directory ${testDir}:`, error);
     }
-  };
+
+    // Always include the main test file
+    if (!files.includes(src)) {
+      files.push(src);
+    }
+
+    return files;
+  }
 }