testeranto 0.189.0 → 0.198.0

package/dist/module/src/PM/main.js

@@ -10,6 +10,10 @@ import path from "path";
 import puppeteer 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 { getRunnables } from "../utils";
 import { Queue } from "../utils/queue.js";
 import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
@@ -166,6 +170,10 @@ export class PM_Main extends PM_WithEslintAndTsc {
         super(configs, name, mode);
         this.logStreams = {};
         this.sidecars = {};
+        this.clients = new Set();
+        this.runningProcesses = new Map();
+        this.allProcesses = new Map();
+        this.processLogs = new Map();
         this.getRunnables = (tests, testName, payload = {
             nodeEntryPoints: {},
             nodeEntryPointSidecars: {},
@@ -310,7 +318,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
                 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);
+                logs.exit.write("-1");
                 this.bddTestIsNowDone(src, -1);
                 statusMessagePretty(-1, src, "pure");
             }
@@ -890,7 +898,24 @@ import('${d}').then(async (x) => {
         };
         this.receiveFeaturesV2 = (reportDest, srcTest, platform) => {
             const featureDestination = path.resolve(process.cwd(), "reports", "features", "strings", 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) => {
                 const accum = await mm;
@@ -933,7 +958,7 @@ import('${d}').then(async (x) => {
                 return accum;
             }, Promise.resolve({ files: [], strings: [] }))
                 .then(({ files, strings }) => {
-                // 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
                     .split(".")
                     .slice(0, -1)
@@ -1006,6 +1031,196 @@ import('${d}').then(async (x) => {
         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) => {
+                var _a, _b;
+                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
+                            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.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(),
+                                });
+                            });
+                            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.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, Object.assign(Object.assign({}, 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, Object.assign(Object.assign({}, 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 === null || childProcess === void 0 ? void 0 : 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) {
         console.log(ansiC.green(ansiC.inverse(`stopSideCar ${uid}`)));
@@ -1164,7 +1379,7 @@ import('${d}').then(async (x) => {
                 },
             ],
         ].forEach(async ([eps, launcher, runtime, watcher]) => {
-            const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+            const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
             await pollForFile(metafile);
             Object.entries(eps).forEach(async ([inputFile, outputFile]) => {
                 // await pollForFile(outputFile);\
@@ -1233,11 +1448,24 @@ import('${d}').then(async (x) => {
         this.importMetafileWatcher.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();
     }
     async metafileOutputs(platform) {
         const metafile = JSON.parse(fs
-            .readFileSync(`./testeranto/bundles/${platform}/${this.name}/metafile.json`)
+            .readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`)
             .toString()).metafile;
         if (!metafile)
             return;
@@ -1279,6 +1507,144 @@ import('${d}').then(async (x) => {
             }
         });
     }
+    requestHandler(req, res) {
+        // 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() {
+        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) {
+        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/dist/module/src/PM/node.js

@@ -110,8 +110,10 @@ 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("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     async createWriteStream(filepath) {

package/dist/module/src/PM/pure.js

@@ -4,24 +4,29 @@ import { PM } from ".";
 const fPaths = [];
 export class PM_Pure extends PM {
     getInnerHtml(selector, page) {
-        throw new Error("pure.ts getInnHtml not implemented");
-        return Promise.resolve("");
+        throw new Error("pure.ts getInnerHtml not implemented");
     }
     stopSideCar(uid) {
-        throw new Error("pure.ts getInnHtml not implemented");
-        return Promise.resolve(true);
+        throw new Error("pure.ts stopSideCar not implemented");
     }
     constructor(t) {
         super();
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    trackCall(method, args) {
+        // Track calls if needed
+    }
     start() {
         return new Promise((r) => r());
     }
     stop() {
         return new Promise((r) => r());
     }
+    async createWriteStream(filepath, testName) {
+        throw new Error("pure.ts createWriteStream not implemented");
+        return "";
+    }
     launchSideCar(n) {
         return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
     }
@@ -73,29 +78,20 @@ export class PM_Pure extends PM {
     customScreenShot(opts, page) {
         return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
     }
+    // TODO: fix these
     existsSync(destFolder) {
-        // Pure runtime doesn't need filesystem checks
         return Promise.resolve(true);
     }
     mkdirSync() {
-        // Pure runtime doesn't need directories
         return true;
     }
     write(uid, contents) {
-        // 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) {
         return globalThis["end"](uid);
     }
@@ -103,47 +99,9 @@ export class PM_Pure extends PM {
         globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
     }
     testArtiFactoryfileWriter(tLog, callback) {
-        // 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();
-        //           });
-        //         }
-        //       });
-        //     })
-        //   );
-        // };
+        return (fPath, value) => {
+            this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+            callback(Promise.resolve());
+        };
     }
 }

package/dist/module/src/PM/web.js

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

package/dist/module/src/Pure.js

@@ -1,7 +1,7 @@
-import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
+import Tiposkripto from "./lib/Tiposkripto.js";
 import { PM_Pure } from "./PM/pure.js";
-export class PureTesteranto extends Testeranto {
+export class PureTesteranto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
             // no-op