testeranto 0.100.0 → 0.111.0

package/src/PM/main.ts

@@ -1,5 +1,7 @@
+import ts from "typescript";
+
 import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
-import fs from "fs";
+import fs, { watch } from "fs";
 import path from "path";
 import puppeteer, {
   Browser,
@@ -9,35 +11,121 @@ import puppeteer, {
   ScreenshotOptions,
 } from "puppeteer-core";
 import { PassThrough } from "stream";
-import crypto from "crypto";
-
-import { IBuiltConfig, IFinalResults, ITestTypes } from "../lib/types";
-import { ITLog } from "../lib/index.js";
+import ansiC from "ansi-colors";
+import crypto from "node:crypto";
+import { ESLint } from "eslint";
+import tsc from "tsc-prog";
+import {
+  IBuiltConfig,
+  IFinalResults,
+  IRunnables,
+  ITestTypes,
+  ITLog,
+} from "../lib/index.js";
+import {
+  bddExitCodePather,
+  lintExitCodePather,
+  lintPather,
+  tscExitCodePather,
+  tscPather,
+} from "../utils";
 
 import { PM } from "./index.js";
 
+type IOutputs = Record<
+  string,
+  {
+    entryPoint: string;
+    inputs: Record<string, string>;
+  }
+>;
+const eslint = new ESLint();
+const formatter = await eslint.loadFormatter(
+  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
+);
+const changes: Record<string, string> = {};
+const fileHashes = {};
 const fileStreams3: fs.WriteStream[] = [];
-
 type IFPaths = string[];
-
 const fPaths: IFPaths = [];
-
 const files: Record<string, Set<string>> = {};
 const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
-const red = "\x1b[31m";
-const green = "\x1b[32m";
-const reset = "\x1b[0m"; // Resets to default color
+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 getRunnables = (
+  tests: ITestTypes[],
+  payload = {
+    nodeEntryPoints: {},
+    webEntryPoints: {},
+  }
+): IRunnables => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path.resolve(
+        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path.resolve(
+        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    }
+
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
+    }
+
+    return pt;
+  }, payload as IRunnables);
+};
 
 const statusMessagePretty = (failures: number, test: string) => {
   if (failures === 0) {
-    console.log(green + `${test} completed successfully` + reset);
+    console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
   } else {
-    console.log(red + `${test} failed ${failures} times` + reset);
+    console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
   }
 };
 
+async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path.dirname(filePath);
+
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+    await fs.appendFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
 export class PM_Main extends PM {
   browser: Browser;
 
@@ -45,21 +133,61 @@ export class PM_Main extends PM {
   configs: IBuiltConfig;
   ports: Record<number, boolean>;
   queue: any[];
-  registry: Record<string, boolean>;
+
+  mode: "DEV" | "PROD";
+
+  bigBoard: Record<
+    string,
+    {
+      // status: "?" | "running" | "waiting";
+      runTimeError?: number | "?";
+      typeErrors?: number | "?";
+      staticErrors?: number | "?";
+      prompt?: string | "?";
+    }
+  > = {};
+  webMetafileWatcher: fs.FSWatcher;
+  nodeMetafileWatcher: fs.FSWatcher;
 
   constructor(configs: IBuiltConfig) {
     super();
+
+    this.mode = configs.devMode ? "DEV" : "PROD";
+
+    process.stdin.on("keypress", (str, key) => {
+      if (key.name === "q") {
+        console.log(
+          ansiC.inverse("Testeranto-Run is shutting down gracefully...")
+        );
+        this.mode = "PROD";
+        // onDone();
+        this.nodeMetafileWatcher.close();
+        this.webMetafileWatcher.close();
+        this.shutDown();
+      }
+    });
+
     this.server = {};
     this.configs = configs;
     this.ports = {};
-    this.registry = {};
+
+    this.configs.tests.forEach(([t]) => {
+      this.bigBoard[t] = {
+        // status: "?",
+        runTimeError: "?",
+        typeErrors: "?",
+        staticErrors: "?",
+        prompt: "?",
+      };
+    });
+
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true"; // set ports as open
     });
 
     globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
-      console.log("waitForSelector", pageKey, sel);
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
       await page?.waitForSelector(sel);
@@ -71,18 +199,16 @@ export class PM_Main extends PM {
 
     globalThis["closePage"] = async (pageKey) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
+      /* @ts-ignore:next-line */
       return page.close();
     };
 
-    // globalThis["closePage"] = (p) => {
-    //   console.log("closePage", p);
-    //   return p.close();
-    // };
-
     globalThis["goto"] = async (pageKey: string, url: string) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
       await page?.goto(url);
@@ -111,19 +237,9 @@ export class PM_Main extends PM {
       contents: string,
       testName: string
     ) => {
-      // console.log(testName, "writeFileSync", filepath, testName);
-
-      // Create directories if they don't exist
-      const dir = path.dirname(filepath);
-
-      // console.log(testName, "mkdirSync", dir);
-
-      fs.mkdirSync(dir, {
+      fs.mkdirSync(path.dirname(filepath), {
         recursive: true,
       });
-
-      // console.log(testName, "mkdirSync2");
-
       if (!files[testName]) {
         files[testName] = new Set();
       }
@@ -153,38 +269,13 @@ export class PM_Main extends PM {
       fileStreams3[uid].end();
     };
 
-    // async (ssOpts: ScreenshotOptions, testName: string) => {
-    //   const p = ssOpts.path as string;
-    //   const dir = path.dirname(p);
-    //   fs.mkdirSync(dir, {
-    //     recursive: true,
-    //   });
-    //   if (!files[testName]) {
-    //     files[testName] = new Set();
-    //   }
-    //   files[testName].add(ssOpts.path as string);
-
-    //   const sPromise = page.screenshot({
-    //     ...ssOpts,
-    //     path: p,
-    //   });
-
-    //   if (!screenshots[testName]) {
-    //     screenshots[testName] = [];
-    //   }
-    //   screenshots[testName].push(sPromise);
-    //   // sPromise.then(())
-    //   await sPromise;
-    //   return sPromise;
-    //   // page.evaluate(`window["screenshot done"]`);
-    // };
-
     globalThis["customScreenShot"] = async (
       opts: { path: string },
       pageKey: string,
       testName: string
     ) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
 
@@ -217,6 +308,7 @@ export class PM_Main extends PM {
       pageKey: string
     ) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
 
@@ -235,20 +327,18 @@ export class PM_Main extends PM {
 
       return opts.path;
     };
-
-    // globalThis["customclose"] = (p: string, testName: string) => {
-    //   if (!files[testName]) {
-    //     files[testName] = new Set();
-    //   }
-
-    //   fs.writeFileSync(
-    //     p + "/manifest.json",
-    //     JSON.stringify(Array.from(files[testName]))
-    //   );
-    //   delete files[testName];
-    // };
   }
 
+  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(""))
+      );
+    });
+  };
+
   customclose() {
     throw new Error("Method not implemented.");
   }
@@ -264,7 +354,6 @@ export class PM_Main extends PM {
   goto(p, url: string): any {
     throw new Error("Method not implemented.");
   }
-
   $(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
@@ -274,11 +363,9 @@ export class PM_Main extends PM {
   customScreenShot(opts: object, cdpPage?: CdpPage) {
     throw new Error("Method not implemented.");
   }
-
   end(accessObject: { uid: number }): boolean {
     throw new Error("Method not implemented.");
   }
-
   existsSync(destFolder: string): boolean {
     return fs.existsSync(destFolder);
   }
@@ -372,7 +459,7 @@ export class PM_Main extends PM {
   getAttribute(selector: string, attribute: string) {
     throw new Error("Method not implemented.");
   }
-  isDisabled(selector: string): boolean {
+  isDisabled(selector: string): Promise<boolean> {
     throw new Error("Method not implemented.");
   }
   screencastStop(s: string) {
@@ -380,47 +467,354 @@ export class PM_Main extends PM {
   }
   ////////////////////////////////////////////////////////////////////////////////
 
-  async startPuppeteer(
-    options: LaunchOptions,
-    destfolder: string
-  ): Promise<any> {
-    this.browser = (await puppeteer.launch(options)) as any;
+  async metafileOutputs(platform: "web" | "node") {
+    const metafile = JSON.parse(
+      fs.readFileSync(`docs/${platform}/metafile.json`).toString()
+    ).metafile;
+
+    if (!metafile) return;
+
+    const outputs: IOutputs = metafile.outputs;
+
+    Object.keys(outputs).forEach(async (k) => {
+      const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+        if (!fs.existsSync(i)) 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 this.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);
+        }
+      }
+    });
   }
 
-  ////////////////////////////////////////////////////////////////////////////////
+  async start(): Promise<any> {
+    this.browser = (await puppeteer.launch({
+      slowMo: 1,
+      // timeout: 1,
+      waitForInitialPage: false,
+      executablePath:
+        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
+        "/opt/homebrew/bin/chromium",
+      headless: true,
+      dumpio: true,
+      // timeout: 0,
+      devtools: true,
+
+      args: [
+        "--auto-open-devtools-for-tabs",
+        `--remote-debugging-port=3234`,
+
+        // "--disable-features=IsolateOrigins,site-per-process",
+        "--disable-site-isolation-trials",
+        "--allow-insecure-localhost",
+        "--allow-file-access-from-files",
+        "--allow-running-insecure-content",
+
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        // "--no-zygote",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        // "--disable-features=IsolateOrigins",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--start-maximized",
+      ],
+    })) as any;
+
+    const { nodeEntryPoints, webEntryPoints } = getRunnables(
+      this.configs.tests
+    );
+
+    Object.entries(nodeEntryPoints).forEach(
+      ([k, outputFile]: [string, string]) => {
+        this.launchNode(k, outputFile);
+        try {
+          watch(outputFile, async (e, filename) => {
+            const hash = await fileHash(outputFile);
+            if (fileHashes[k] !== hash) {
+              fileHashes[k] = hash;
+              console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename}`)));
+              this.launchNode(k, outputFile);
+            }
+          });
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    );
+
+    Object.entries(webEntryPoints).forEach(
+      ([k, outputFile]: [string, string]) => {
+        this.launchWeb(k, outputFile);
+        watch(outputFile, async (e, filename) => {
+          const hash = await fileHash(outputFile);
+          if (fileHashes[k] !== hash) {
+            fileHashes[k] = hash;
+            console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename}`)));
+            this.launchWeb(k, outputFile);
+          }
+        });
+      }
+    );
+
+    this.metafileOutputs("node");
+    this.nodeMetafileWatcher = watch(
+      "docs/node/metafile.json",
+      async (e, filename) => {
+        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (node)`)));
+        this.metafileOutputs("node");
+      }
+    );
+
+    this.metafileOutputs("web");
+    this.webMetafileWatcher = watch(
+      "docs/web/metafile.json",
+      async (e, filename) => {
+        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
+        this.metafileOutputs("web");
+      }
+    );
+  }
+
+  // goodbye = () => {
+  //   this.browser.disconnect().then(() => {
+
+  //     console.log("Goodbye");
+  //     process.exit();
+  //   });
+  // };
+
+  tscCheck = async ({
+    entrypoint,
+    addableFiles,
+    platform,
+  }: {
+    platform: "web" | "node";
+    entrypoint: string;
+    addableFiles: string[];
+  }) => {
+    console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
+    console.log(JSON.stringify(this.bigBoard));
+    this.bigBoard[entrypoint].typeErrors = "?";
+
+    const program = tsc.createProgramFromConfig({
+      basePath: process.cwd(), // always required, used for relative paths
+      configFilePath: "tsconfig.json", // config to inherit from (optional)
+      compilerOptions: {
+        rootDir: "src",
+        outDir: tscPather(entrypoint, platform),
+        // declaration: true,
+        // skipLibCheck: true,
+        noEmit: true,
+      },
+      include: addableFiles, //["src/**/*"],
+      // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+    });
+    const tscPath = tscPather(entrypoint, platform);
+
+    let allDiagnostics = program.getSemanticDiagnostics();
+
+    const d: string[] = [];
+    allDiagnostics.forEach((diagnostic) => {
+      if (diagnostic.file) {
+        let { line, character } = ts.getLineAndCharacterOfPosition(
+          diagnostic.file,
+          diagnostic.start!
+        );
+        let message = ts.flattenDiagnosticMessageText(
+          diagnostic.messageText,
+          "\n"
+        );
+        d.push(
+          `${diagnostic.file.fileName} (${line + 1},${
+            character + 1
+          }): ${message}`
+        );
+      } else {
+        d.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+      }
+    });
+
+    fs.writeFileSync(tscPath, d.join("\n"));
+    this.bigBoard[entrypoint].typeErrors = d.length;
+    if (this.shutdownMode) {
+      this.checkForShutdown();
+    }
+    // fs.writeFileSync(
+    //   tscExitCodePather(entrypoint, platform),
+    //   d.length.toString()
+    // );
+  };
+
+  eslintCheck = async (
+    entrypoint: string,
+    platform: "web" | "node",
+    addableFiles: string[]
+  ) => {
+    this.bigBoard[entrypoint].staticErrors = "?";
+    console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
+    const results = (await eslint.lintFiles(addableFiles))
+      .filter((r) => r.messages.length)
+      .filter((r) => {
+        return r.messages[0].ruleId !== null;
+      })
+      .map((r) => {
+        delete r.source;
+        return r;
+      });
+
+    fs.writeFileSync(
+      lintPather(entrypoint, platform),
+      await formatter.format(results)
+    );
+    this.bigBoard[entrypoint].staticErrors = results.length;
+    if (this.shutdownMode) {
+      this.checkForShutdown();
+    }
+    // fs.writeFileSync(
+    //   lintExitCodePather(entrypoint, platform),
+    //   results.length.toString()
+    // );
+  };
+
+  makePrompt = async (
+    entryPoint: string,
+    addableFiles: string[],
+    platform: "web" | "node"
+  ) => {
+    this.bigBoard[entryPoint].prompt = "?";
+    const promptPath = path.join(
+      "./docs/",
+      platform,
+      entryPoint.split(".").slice(0, -1).join("."),
+      `prompt.txt`
+    );
+
+    const testPaths = path.join(
+      "./docs/",
+      platform,
+      entryPoint.split(".").slice(0, -1).join("."),
+      `tests.json`
+    );
+
+    const featuresPath = path.join(
+      "./docs/",
+      platform,
+      entryPoint.split(".").slice(0, -1).join("."),
+      `featurePrompt.txt`
+    );
+
+    fs.writeFileSync(
+      promptPath,
+      `
+${addableFiles
+  .map((x) => {
+    return `/add ${x}`;
+  })
+  .join("\n")}
+
+/read ${lintPather(entryPoint, platform)}
+/read ${tscPather(entryPoint, platform)}
+/read ${testPaths}
+
+/load ${featuresPath}
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${tscPather(
+        entryPoint,
+        platform
+      )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
+        entryPoint,
+        platform
+      )}"
+          `
+    );
+    this.bigBoard[entryPoint].prompt =
+      "aider --model deepseek/deepseek-chat --load docs/web/./src/Rectangle/Rectangle.test.web/prompt.txt";
+    if (this.shutdownMode) {
+      this.checkForShutdown();
+    }
+  };
 
   shutDown() {
-    console.log("shutting down...");
     this.shutdownMode = true;
     this.checkForShutdown();
   }
 
   checkForShutdown = () => {
     const anyRunning: boolean =
-      Object.values(this.registry).filter((x) => x === false).length > 0;
+      Object.values(this.bigBoard).filter((x) => x.prompt === "?").length +
+        Object.values(this.bigBoard).filter((x) => x.runTimeError === "?")
+          .length +
+        Object.values(this.bigBoard).filter((x) => x.staticErrors === "?")
+          .length +
+        Object.values(this.bigBoard).filter((x) => x.typeErrors === "?")
+          .length >
+      0;
     if (anyRunning) {
+      console.log(ansiC.inverse("Shutting down. Please wait"));
     } else {
       this.browser.disconnect().then(() => {
-        console.log("Goodbye");
+        fs.writeFileSync(
+          "docs/summary.json",
+          JSON.stringify(this.bigBoard, null, 2)
+        );
+        console.log(ansiC.inverse("Goodbye"));
         process.exit();
       });
     }
   };
 
-  register = (src: string) => {
-    this.registry[src] = false;
+  testIsNowRunning = (src: string) => {
+    this.bigBoard[src].status = "running";
   };
 
-  deregister = (src: string) => {
-    this.registry[src] = true;
+  testIsNowDone = (src: string) => {
+    this.bigBoard[src].status = "waiting";
     if (this.shutdownMode) {
       this.checkForShutdown();
     }
   };
 
   launchNode = async (src: string, dest: string) => {
-    console.log("! node", src);
-    this.register(src);
+    // console.log(ansiC.yellow(`! node, ${src}`));
+    console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+    this.testIsNowRunning(src);
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -431,7 +825,7 @@ export class PM_Main extends PM {
     });
 
     if (!testConfig) {
-      console.error("missing test config");
+      console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
       process.exit(-1);
     }
     const testConfigResource = testConfig[2];
@@ -510,13 +904,15 @@ export class PM_Main extends PM {
             this.receiveFeatures(features, destFolder, src);
             // console.log(`${src} completed with ${failed} errors`);
             statusMessagePretty(failed, src);
+            this.receiveExitCode(src, failed);
           })
           .catch((e) => {
-            console.log(`${src} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+            // console.log(reset, `${src} errored with`, e);
           })
           .finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.deregister(src);
+            this.testIsNowDone(src);
           });
       });
     });
@@ -535,14 +931,8 @@ export class PM_Main extends PM {
     testConfig: ITestTypes
   ): Promise<Page> => {
     const d = dest + ".mjs";
-    console.log("launchWebSideCar", src, dest, d);
-    const destFolder = dest.replace(".mjs", "");
-    // const webArgz = JSON.stringify({
-    //   name: dest,
-    //   ports: [].toString(),
-    //   fs: destFolder,
-    //   browserWSEndpoint: this.browser.wsEndpoint(),
-    // });
+
+    console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
 
     const fileStreams2: fs.WriteStream[] = [];
     const doneFileStream2: Promise<any>[] = [];
@@ -673,6 +1063,7 @@ export class PM_Main extends PM {
         })
         .then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
+
           res(page);
         });
     });
@@ -684,7 +1075,7 @@ export class PM_Main extends PM {
     testConfig: ITestTypes
   ) => {
     const d = dest + ".mjs";
-    console.log("launchNodeSideCar", src, dest, d);
+    console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -732,10 +1123,6 @@ export class PM_Main extends PM {
 
     const builtfile = dest + ".mjs";
 
-    // console.log(
-    //   "node builtfile",
-    //   (await import(`${builtfile}?cacheBust=${Date.now()}`)).default
-    // );
     this.server[builtfile] = await import(
       `${builtfile}?cacheBust=${Date.now()}`
     ).then((module) => {
@@ -757,7 +1144,6 @@ export class PM_Main extends PM {
       });
     });
 
-    // console.log("portsToUse", portsToUse);
     for (let i = 0; i <= portsToUse.length; i++) {
       if (portsToUse[i]) {
         this.ports[portsToUse[i]] = "true"; //port is open again
@@ -766,8 +1152,9 @@ export class PM_Main extends PM {
   };
 
   launchWeb = (t: string, dest: string) => {
-    console.log("! web", t);
-    this.register(t);
+    // console.log(green, "! web", t);
+    console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+    this.testIsNowRunning(t);
 
     // sidecars.map((sidecar) => {
     //   if (sidecar[1] === "node") {
@@ -791,9 +1178,9 @@ export class PM_Main extends PM {
     const d = `${dest}?cacheBust=${Date.now()}`;
 
     const evaluation = `
-    console.log("importing ${d}");
+
     import('${d}').then(async (x) => {
-      console.log("imported", (await x.default));
+
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -982,7 +1369,7 @@ export class PM_Main extends PM {
         // });
 
         page.exposeFunction("page", () => {
-          return page.mainFrame()._id;
+          return (page.mainFrame() as unknown as { _id: string })._id;
         });
 
         page.exposeFunction("click", (sel) => {
@@ -1048,7 +1435,7 @@ export class PM_Main extends PM {
             delete screenshots[t];
             page.close();
 
-            this.deregister(t);
+            this.testIsNowDone(t);
             stderrStream.close();
             stdoutStream.close();
           });
@@ -1070,7 +1457,7 @@ export class PM_Main extends PM {
 
           console.debug(`Error from message ${t}: [${err.message}] `);
           stderrStream.write(err.message);
-          // close();
+          close();
         });
         page.on("console", (log: ConsoleMessage) => {
           // console.debug(`Log from ${t}: [${log.text()}] `);
@@ -1090,11 +1477,14 @@ export class PM_Main extends PM {
             this.receiveFeatures(features, destFolder, t);
             // console.log(`${t} completed with ${failed} errors`);
             statusMessagePretty(failed, t);
+            this.receiveExitCode(t, failed);
           })
           .catch((e) => {
-            console.log(`${t} errored with`, e);
+            // console.log(red, `${t} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
           })
           .finally(() => {
+            // this.testIsNowDone(t);
             close();
           });
 
@@ -1141,13 +1531,13 @@ export class PM_Main extends PM {
               }
             }
 
-            fs.symlink(u.pathname, newPath, (err) => {
-              if (err) {
-                // console.error("Error creating symlink:", err);
-              } else {
-                // console.log("Symlink created successfully");
-              }
-            });
+            // fs.symlink(u.pathname, newPath, (err) => {
+            //   if (err) {
+            //     // console.error("Error creating symlink:", err);
+            //   } else {
+            //     // console.log("Symlink created successfully");
+            //   }
+            // });
             accum.files.push(newPath);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
             const newPath = `${process.cwd()}/docs/features/external${
@@ -1161,13 +1551,7 @@ export class PM_Main extends PM {
           await fs.promises.mkdir(path.dirname(featureDestination), {
             recursive: true,
           });
-          // const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
-          //   featureStringKey
-          // )}`;
-          // writeFileAndCreateDir(
-          //   `${featureDestination}/${await sha256(featureStringKey)}`,
-          //   featureStringKey
-          // );
+
           accum.strings.push(featureStringKey);
         }
 
@@ -1186,35 +1570,19 @@ export class PM_Main extends PM {
             .join("\n")
         );
       });
-  };
-}
 
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path.dirname(filePath);
-
-  try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.appendFileSync(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-
-async function sha256(rawData) {
-  const data =
-    typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
+    // this.writeBigBoard();
+  };
 
-  const msgBuffer = new TextEncoder().encode(data);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
+  receiveExitCode = (srcTest: string, failures: number) => {
+    this.bigBoard[srcTest].runTimeError = failures;
+    this.writeBigBoard();
+  };
 
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
+  writeBigBoard = () => {
+    fs.writeFileSync(
+      "./docs/summary.json",
+      JSON.stringify(this.bigBoard, null, 2)
+    );
+  };
 }