testeranto 0.189.0 → 0.197.0

package/src/PM/main.ts

@@ -12,6 +12,10 @@ import path from "path";
 import puppeteer, { 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,
@@ -241,6 +245,24 @@ export class PM_Main extends PM_WithEslintAndTsc {
   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);
 
@@ -255,6 +277,222 @@ export class PM_Main extends PM_WithEslintAndTsc {
     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> {
@@ -438,7 +676,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
         IRunTime,
         (f: fs.FSWatcher) => void
       ]) => {
-        const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+        const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
 
         await pollForFile(metafile);
 
@@ -526,6 +764,22 @@ export class PM_Main extends PM_WithEslintAndTsc {
     // 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();
   }
 
@@ -547,9 +801,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
   async metafileOutputs(platform: IRunTime) {
     const metafile = JSON.parse(
       fs
-        .readFileSync(
-          `./testeranto/bundles/${platform}/${this.name}/metafile.json`
-        )
+        .readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`)
         .toString()
     ).metafile;
 
@@ -1514,9 +1766,28 @@ import('${d}').then(async (x) => {
       srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
     );
 
-    const testReport = JSON.parse(
-      fs.readFileSync(`${reportDest}/tests.json`).toString()
-    );
+    // Read and parse the test report
+    const testReportPath = `${reportDest}/tests.json`;
+    if (!fs.existsSync(testReportPath)) {
+      console.error(`tests.json not found at: ${testReportPath}`);
+      return;
+    }
+
+    const testReport = JSON.parse(fs.readFileSync(testReportPath, "utf8"));
+
+    // Add full path information to each test
+    if (testReport.tests) {
+      testReport.tests.forEach((test) => {
+        // Add the full path to each test
+        test.fullPath = path.resolve(process.cwd(), srcTest);
+      });
+    }
+
+    // Add full path to the report itself
+    testReport.fullPath = path.resolve(process.cwd(), srcTest);
+
+    // Write the modified report back
+    fs.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
 
     testReport.features
       .reduce(async (mm, featureStringKey) => {
@@ -1574,7 +1845,7 @@ import('${d}').then(async (x) => {
       }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
 
       .then(({ files, strings }: { files: string[]; strings: string[] }) => {
-        // Markdown files must be referenced in the prompt but string style features are already present in the test.json file
+        // Markdown files must be referenced in the prompt but string style features are already present in the tests.json file
 
         fs.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest
@@ -1601,6 +1872,151 @@ import('${d}').then(async (x) => {
     this.writeBigBoard();
   };
 
+  requestHandler(req: http.IncomingMessage, res: http.ServerResponse) {
+    // Parse the URL
+    const parsedUrl = url.parse(req.url || "/");
+    let pathname = parsedUrl.pathname || "/";
+
+    // Handle root path
+    if (pathname === "/") {
+      pathname = "/index.html";
+    }
+
+    // Remove leading slash
+    let filePath = pathname.substring(1);
+
+    // Determine which directory to serve from
+    if (filePath.startsWith("reports/")) {
+      // Serve from reports directory
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath.startsWith("metafiles/")) {
+      // Serve from metafiles directory
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath === "projects.json") {
+      // Serve projects.json
+      filePath = `testeranto/${filePath}`;
+    } else {
+      // For frontend assets, try multiple possible locations
+      // First, try the dist directory
+      const possiblePaths = [
+        `dist/${filePath}`,
+        `testeranto/dist/${filePath}`,
+        `../dist/${filePath}`,
+        `./${filePath}`,
+      ];
+
+      // Find the first existing file
+      let foundPath = null;
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          foundPath = possiblePath;
+          break;
+        }
+      }
+
+      if (foundPath) {
+        filePath = foundPath;
+      } else {
+        // If no file found, serve index.html for SPA routing
+        const indexPath = this.findIndexHtml();
+        if (indexPath) {
+          fs.readFile(indexPath, (err, data) => {
+            if (err) {
+              res.writeHead(404, { "Content-Type": "text/plain" });
+              res.end("404 Not Found");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(data);
+          });
+          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;
+          }
+        }
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+        return;
+      }
+
+      // Read and serve the file
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("500 Internal Server Error");
+          return;
+        }
+
+        // Get MIME type
+        const mimeType = mime.lookup(filePath) || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": mimeType });
+        res.end(data);
+      });
+    });
+  }
+
+  findIndexHtml(): string | null {
+    const possiblePaths = [
+      "dist/index.html",
+      "testeranto/dist/index.html",
+      "../dist/index.html",
+      "./index.html",
+    ];
+
+    for (const path of possiblePaths) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+    return null;
+  }
+
+  broadcast(message: any) {
+    const data =
+      typeof message === "string" ? message : JSON.stringify(message);
+    this.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        // WebSocket.OPEN
+        client.send(data);
+      }
+    });
+  }
+
   checkQueue() {
     const x = this.queue.pop();
     if (!x) {

package/src/PM/node.ts

@@ -185,8 +185,11 @@ export class PM_Node extends PM {
   async writeFileSync(x) {
     const z = arguments["0"];
 
-    const filepath = z[0];
-    const contents = z[1];
+    // const filepath = z[0];
+    // const contents = z[1];
+
+    const filepath = arguments[0];
+    const contents = arguments[1];
 
     return await this.send<boolean>(
       "writeFileSync",

package/src/PM/pure.ts

@@ -15,13 +15,11 @@ type PuppetMasterServer = Record<string, Promise<any>>;
 
 export class PM_Pure extends PM {
   getInnerHtml(selector: string, page: string): Promise<string> {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve("");
+    throw new Error("pure.ts getInnerHtml not implemented");
   }
 
-  stopSideCar(uid: number): Promise<boolean> {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve(true);
+  stopSideCar(uid: number): Promise<any> {
+    throw new Error("pure.ts stopSideCar not implemented");
   }
   server: PuppetMasterServer;
   testResourceConfiguration: ITTestResourceConfiguration;
@@ -32,6 +30,10 @@ export class PM_Pure extends PM {
     this.testResourceConfiguration = t;
   }
 
+  protected trackCall(method: string, args: any) {
+    // Track calls if needed
+  }
+
   start(): Promise<void> {
     return new Promise((r) => r());
   }
@@ -40,6 +42,11 @@ export class PM_Pure extends PM {
     return new Promise((r) => r());
   }
 
+  async createWriteStream(filepath: string, testName: string): Promise<string> {
+    throw new Error("pure.ts createWriteStream not implemented");
+    return "";
+  }
+
   launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
     return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
   }
@@ -111,7 +118,7 @@ export class PM_Pure extends PM {
     return globalThis["screencastStop"](p);
   }
 
-  customScreenShot(opts: ScreencastOptions, page: string) {
+  customScreenShot(opts: { path: string }, page?: string) {
     return globalThis["customScreenShot"](
       {
         ...opts,
@@ -122,33 +129,23 @@ export class PM_Pure extends PM {
     );
   }
 
+  // TODO: fix these
   existsSync(destFolder: string): Promise<boolean> {
-    // Pure runtime doesn't need filesystem checks
     return Promise.resolve(true);
   }
 
   mkdirSync() {
-    // Pure runtime doesn't need directories
     return true;
   }
 
   write(uid: number, contents: string) {
-    // Pure runtime doesn't need file writing
     return Promise.resolve(true);
   }
 
   writeFileSync() {
-    // Pure runtime doesn't need file writing
     return Promise.resolve(true);
   }
-
-  createWriteStream() {
-    // Pure runtime doesn't need file streams
-    return {
-      write: () => true,
-      end: () => {}
-    };
-  }
+  /////////////////////////////////////////////////////
 
   end(uid: number) {
     return globalThis["end"](uid);
@@ -161,49 +158,14 @@ export class PM_Pure extends PM {
     );
   }
 
-  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
-    // return (fPath, value: string | Buffer | PassThrough) => {
-    //   callback(
-    //     new Promise<void>((res) => {
-    //       tLog("testArtiFactory =>", fPath);
-    //       const cleanPath = path.resolve(fPath);
-    //       fPaths.push(cleanPath.replace(process.cwd(), ``));
-    //       const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-    //       fs.mkdir(targetDir, { recursive: true }, async (error) => {
-    //         if (error) {
-    //           console.error(`❗️testArtiFactory failed`, targetDir, error);
-    //         }
-    //         fs.writeFileSync(
-    //           path.resolve(
-    //             targetDir.split("/").slice(0, -1).join("/"),
-    //             "manifest"
-    //           ),
-    //           fPaths.join(`\n`),
-    //           {
-    //             encoding: "utf-8",
-    //           }
-    //         );
-    //         if (Buffer.isBuffer(value)) {
-    //           fs.writeFileSync(fPath, value, "binary");
-    //           res();
-    //         } else if (`string` === typeof value) {
-    //           fs.writeFileSync(fPath, value.toString(), {
-    //             encoding: "utf-8",
-    //           });
-    //           res();
-    //         } else {
-    //           const pipeStream: PassThrough = value;
-    //           const myFile = fs.createWriteStream(fPath);
-    //           pipeStream.pipe(myFile);
-    //           pipeStream.on("close", () => {
-    //             myFile.close();
-    //             res();
-    //           });
-    //         }
-    //       });
-    //     })
-    //   );
-    // };
+  testArtiFactoryfileWriter(
+    tLog: ITLog,
+    callback: (promise: Promise<any>) => void
+  ) {
+    return (fPath: string, value: string | Buffer | any) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
   }
 
   // startPuppeteer(options?: any): any {

package/src/PM/web.ts

@@ -137,10 +137,14 @@ export class PM_Web extends PM {
 
   writeFileSync(x) {
     // eslint-disable-next-line prefer-rest-params
-    const z = arguments["0"];
+    // const z = arguments["0"];
+
+    // const filepath = z[0];
+    // const contents = z[1];
+
+    const filepath = arguments[0];
+    const contents = arguments[1];
 
-    const filepath = z[0];
-    const contents = z[1];
     return window["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,