testeranto 0.219.13 → 0.219.15

package/dist/module/src/server/serverClasees/Server_FS.js

@@ -1,119 +0,0 @@
-"use strict";
-// import fs from "fs";
-// import path from "path";
-// import { IMode } from "../types";
-// import { IBuiltConfig, IRunTime, ISummary } from "../../Types";
-// import { makeHtmlTestFiles } from "../../makeHtmlTestFiles";
-// import { makeHtmlReportFile } from "../../makeHtmlReportFile";
-// import { Server_WS } from "./Server_WS";
-// import { getRunnables } from "../getRunnables";
-// import { IndexHtml } from "../serverManagers/fs";
-// export class Server_FS extends Server_WS {
-//   summary: ISummary = {};
-//   currentBuildResolve: (() => void) | null = null;
-//   currentBuildReject: ((error: any) => void) | null = null;
-//   constructor(configs: IBuiltConfig, testName: string, mode: IMode, routes) {
-//     super(configs, testName, mode, routes);
-//     fs.writeFileSync(
-//       path.join(process.cwd(), "testeranto", `${testName}.json`),
-//       JSON.stringify(configs, null, 2)
-//     );
-//     if (!fs.existsSync(`testeranto/reports/${testName}`)) {
-//       fs.mkdirSync(`testeranto/reports/${testName}`);
-//     }
-//     fs.writeFileSync(
-//       `testeranto/reports/${testName}/config.json`,
-//       JSON.stringify(configs, null, 2)
-//     );
-//     makeHtmlTestFiles(testName);
-//     makeHtmlReportFile(testName, configs);
-//     const {
-//       nodeEntryPoints,
-//       webEntryPoints,
-//       pythonEntryPoints,
-//       golangEntryPoints,
-//     } = getRunnables(configs, testName);
-//     // create the necessary folders for all tests
-//     [
-//       ["node", Object.keys(nodeEntryPoints)],
-//       ["web", Object.keys(webEntryPoints)],
-//       ["python", Object.keys(pythonEntryPoints)],
-//       ["golang", Object.keys(golangEntryPoints)],
-//     ].forEach(async ([runtime, keys]: [IRunTime, string[]]) => {
-//       keys.forEach(async (k) => {
-//         fs.mkdirSync(
-//           `testeranto/reports/${testName}/${k
-//             .split(".")
-//             .slice(0, -1)
-//             .join(".")}/${runtime}`,
-//           { recursive: true }
-//         );
-//       });
-//     });
-//     setupFileSystem(configs, testName);
-//     if (!fs.existsSync(`testeranto/reports/${this.projectName}`)) {
-//       fs.mkdirSync(`testeranto/reports/${this.projectName}`);
-//     }
-//   }
-//   ensureSummaryEntry(src: string, isSidecar = false) {
-//     if (!this.summary[src]) {
-//       this.summary[src] = {
-//         runTimeTests: undefined,
-//         runTimeErrors: undefined,
-//         typeErrors: undefined,
-//         staticErrors: undefined,
-//         prompt: undefined,
-//         failingFeatures: undefined,
-//       };
-//     }
-//     return this.summary[src];
-//   }
-//   getSummary() {
-//     return this.summary;
-//   }
-//   setSummary(summary: ISummary) {
-//     this.summary = summary;
-//   }
-//   updateSummaryEntry(
-//     src: string,
-//     updates: Partial<{
-//       typeErrors: number | "?" | undefined;
-//       staticErrors: number | "?" | undefined;
-//       runTimeErrors: number | "?" | undefined;
-//       prompt: string | "?" | undefined;
-//       failingFeatures: object | undefined;
-//     }>
-//   ) {
-//     if (!this.summary[src]) {
-//       this.ensureSummaryEntry(src);
-//     }
-//     this.summary[src] = { ...this.summary[src], ...updates };
-//   }
-//   writeBigBoard = () => {
-//     const summaryPath = `./testeranto/reports/${this.projectName}/summary.json`;
-//     const summaryData = JSON.stringify(this.summary, null, 2);
-//     fs.writeFileSync(summaryPath, summaryData);
-//     // Broadcast the update if WebSocket is available
-//     // if (this.webSocketBroadcastMessage) {
-//     //   this.webSocketBroadcastMessage({
-//     //     type: "summaryUpdate",
-//     //     data: this.summary,
-//     //   });
-//     // }
-//   };
-//   async stop() {
-//     await super.stop();
-//   }
-// }
-// function setupFileSystem(config: IBuiltConfig, testsName: string) {
-//   fs.writeFileSync(`${process.cwd()}/testeranto/index.html`, IndexHtml());
-//   // Create reports directory
-//   if (!fs.existsSync(`testeranto/reports/${testsName}`)) {
-//     fs.mkdirSync(`testeranto/reports/${testsName}`, { recursive: true });
-//   }
-//   // Write config to reports
-//   fs.writeFileSync(
-//     `testeranto/reports/${testsName}/config.json`,
-//     JSON.stringify(config, null, 2)
-//   );
-// }

package/dist/module/src/server/serverClasees/Server_HTTP.js

@@ -1,182 +0,0 @@
-// Gives the server HTTP capabilities
-// 1) serve static files from the project directory
-// 2) handle HTTP requests which are defined by child classes.
-////  for instance, Server_Process_Manager will define the react component.
-////  So we want the Server_Process_Manager class to handle the react component and logic defined by that child class
-////  These extra pages are routed under the ~ (tilde) to seperate the file server from the extra commands
-import fs from "fs";
-import http from "http";
-import path from "path";
-import { CONTENT_TYPES, getContentType } from "../serverManagers/tcp";
-import { Server_Base } from "./Server_Base";
-export class Server_HTTP extends Server_Base {
-    constructor(configs, mode) {
-        super(configs, mode);
-        // this.http = new HttpManager();
-        this.httpServer = http.createServer();
-        this.httpServer.on("error", (error) => {
-            console.error(`[HTTP] error:`, error);
-        });
-        this.httpServer.on("request", this.handleHttpRequest.bind(this));
-        // Note: WebSocket upgrade handling will be set up by child classes if needed
-        // Do not call setupWebSocketUpgrade() here
-    }
-    async start() {
-        console.log(`[Server_HTTP] start()`);
-        super.start();
-        return new Promise((resolve) => {
-            this.httpServer.on("listening", () => {
-                const addr = this.httpServer.address();
-                console.log(`[HTTP] HTTP server is now listening on ${addr}`);
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        console.log(`[Server_HTTP] stop()`);
-        this.httpServer.close(() => {
-            console.log("[HTTP] HTTP server closed");
-        });
-        await super.stop();
-    }
-    handleHttpRequest(req, res) {
-        console.log(`[Server_HTTP] handleHttpRequest(${req.url})`);
-        // Check if this is a route request (starts with /~/)
-        if (req.url && req.url.startsWith("/~/")) {
-            this.handleRouteRequest(req, res);
-        }
-        else {
-            // Otherwise serve static files
-            this.serveStaticFile(req, res);
-        }
-    }
-    handleRouteRequest(req, res) {
-        console.log(`[Server_HTTP] handleRouteRequest(${req.url})`);
-        const routeName = this.http.routeName(req);
-        console.log(`[HTTP] Handling route: /~/${routeName}`);
-        // Use HttpManager to match the route
-        const match = this.http.matchRoute(routeName, this.routes);
-        if (match) {
-            // Add params to request object for handler to use
-            req.params = match.params;
-            try {
-                match.handler(req, res);
-            }
-            catch (error) {
-                console.error(`[HTTP] Error in route handler for /~/${routeName}:`, error);
-                res.writeHead(500, { "Content-Type": "text/plain" });
-                res.end(`Internal Server Error: ${error}`);
-            }
-            return;
-        }
-        // No route found
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end(`Route not found: /~/${routeName}`);
-    }
-    serveStaticFile(req, res) {
-        console.log(`[Server_HTTP] serveStaticFile(${req.url})`);
-        if (!req.url) {
-            res.writeHead(400);
-            res.end("Bad Request");
-            return;
-        }
-        const normalizedPath = this.http.decodedPath(req);
-        // Check for any remaining '..' components
-        if (normalizedPath.includes("..")) {
-            res.writeHead(403);
-            res.end("Forbidden: Directory traversal not allowed");
-            return;
-        }
-        // Start from the project root (current working directory)
-        const projectRoot = process.cwd();
-        const filePath = path.join(projectRoot, normalizedPath);
-        // Ensure the file is within the project root
-        if (!filePath.startsWith(path.resolve(projectRoot))) {
-            res.writeHead(403);
-            res.end("Forbidden");
-            return;
-        }
-        // Check if it's a directory
-        fs.stat(filePath, (err, stats) => {
-            if (err) {
-                if (err.code === "ENOENT") {
-                    res.writeHead(404);
-                    res.end(`File not found: ${normalizedPath}`);
-                    return;
-                }
-                else {
-                    res.writeHead(500);
-                    res.end(`Server Error: ${err.message}`);
-                    return;
-                }
-            }
-            if (stats.isDirectory()) {
-                // List directory contents
-                fs.readdir(filePath, (readErr, files) => {
-                    if (readErr) {
-                        res.writeHead(500);
-                        res.end(`Server Error: ${readErr.message}`);
-                        return;
-                    }
-                    // Generate directory listing
-                    const items = files
-                        .map((file) => {
-                        try {
-                            const stat = fs.statSync(path.join(filePath, file));
-                            const isDir = stat.isDirectory();
-                            const slash = isDir ? "/" : "";
-                            return `<li><a href="${path.join(normalizedPath, file)}${slash}">${file}${slash}</a></li>`;
-                        }
-                        catch (_a) {
-                            // If we can't stat the file, still show it as a link without slash
-                            return `<li><a href="${path.join(normalizedPath, file)}">${file}</a></li>`;
-                        }
-                    })
-                        .join("");
-                    res.writeHead(200, { "Content-Type": "text/html" });
-                    res.end(`
-            <!DOCTYPE html>
-            <html>
-            <head><title>Directory listing for ${normalizedPath}</title></head>
-            <body>
-              <h1>Directory listing for ${normalizedPath}</h1>
-              <ul>
-                ${items}
-              </ul>
-            </body>
-            </html>
-          `);
-                });
-            }
-            else {
-                this.serveFile(filePath, res);
-            }
-        });
-    }
-    serveFile(filePath, res) {
-        console.log(`[Server_HTTP] serveFile(${filePath})`);
-        const contentType = getContentType(filePath) || CONTENT_TYPES.OCTET_STREAM;
-        fs.readFile(filePath, (err, data) => {
-            if (err) {
-                if (err.code === "ENOENT") {
-                    res.writeHead(404);
-                    res.end(`File not found: ${filePath}`);
-                }
-                else {
-                    res.writeHead(500);
-                    res.end(`Server Error: ${err.message}`);
-                }
-                return;
-            }
-            res.writeHead(200, { "Content-Type": contentType });
-            res.end(data);
-        });
-    }
-    // The route method is no longer abstract since we're using the routes() method
-    // This is kept for backward compatibility
-    router(a) {
-        // Default implementation does nothing
-        // Inheriting classes can override if needed
-        return a;
-    }
-}

package/dist/module/src/server/serverClasees/Server_WS.js

@@ -1,258 +0,0 @@
-// Gives the server websocket capabilities
-import { WebSocket, WebSocketServer } from "ws";
-import { WsManager } from "../serverManagers/WsManager";
-import { Server_HTTP } from "./Server_HTTP";
-export class Server_WS extends Server_HTTP {
-    constructor(configs, mode) {
-        super(configs, mode);
-        this.wsClients = new Set();
-        this.ws = new WebSocketServer({
-            noServer: true,
-        });
-        this.wsManager = new WsManager();
-        this.setupWebSocketHandlers();
-    }
-    async start() {
-        console.log(`[Server_WS] start()`);
-        await super.start();
-        this.attachWebSocketToHttpServer(this.httpServer);
-    }
-    async stop() {
-        console.log(`[Server_WS] stop()`);
-        this.wsClients.forEach((client) => {
-            client.close();
-        });
-        this.wsClients.clear();
-        // Close the WebSocket server
-        this.ws.close(() => {
-            console.log("[WebSocket] Server closed");
-        });
-        await super.stop();
-    }
-    escapeXml(unsafe) {
-        return this.wsManager.escapeXml(unsafe);
-    }
-    attachWebSocketToHttpServer(httpServer) {
-        httpServer.on("upgrade", (request, socket, head) => {
-            const pathname = new URL(request.url || "", `http://${request.headers.host}`).pathname;
-            // Handle WebSocket connections at /ws
-            if (pathname === "/ws") {
-                console.log("[WebSocket] Upgrade request for /ws");
-                this.ws.handleUpgrade(request, socket, head, (ws) => {
-                    this.ws.emit("connection", ws, request);
-                });
-            }
-            else {
-                // Close connection for non-WebSocket paths
-                socket.destroy();
-            }
-        });
-    }
-    broadcast(message) {
-        const data = typeof message === "string" ? message : JSON.stringify(message);
-        console.log(`[WebSocket] Broadcasting to ${this.wsClients.size} clients:`, message.type || message);
-        let sentCount = 0;
-        this.wsClients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(data);
-                sentCount++;
-            }
-            else {
-                console.log(`[WebSocket] Client not open, state: ${client.readyState}`);
-            }
-        });
-        console.log(`[WebSocket] Sent to ${sentCount} clients`);
-    }
-    setupWebSocketHandlers() {
-        this.ws.on("connection", (ws, request) => {
-            console.log(`[WebSocket] New connection from ${request.socket.remoteAddress}`);
-            this.wsClients.add(ws);
-            // Send initial connection message
-            ws.send(JSON.stringify({
-                type: "connected",
-                message: "Connected to Process Manager WebSocket",
-                timestamp: new Date().toISOString()
-            }));
-            // Immediately send current processes
-            // Note: handleGetProcesses needs to be implemented or handled differently
-            // For now, we'll send a placeholder
-            ws.send(JSON.stringify({
-                type: "processes",
-                data: this.getProcessSummary ? this.getProcessSummary() : { processes: [] },
-                timestamp: new Date().toISOString()
-            }));
-            // Handle messages from clients
-            ws.on("message", (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    this.handleWebSocketMessage(ws, message);
-                }
-                catch (error) {
-                    console.error("[WebSocket] Error parsing message:", error);
-                    ws.send(JSON.stringify({
-                        type: "error",
-                        message: "Invalid JSON message",
-                        timestamp: new Date().toISOString()
-                    }));
-                }
-            });
-            // Handle client disconnection
-            ws.on("close", () => {
-                console.log("[WebSocket] Client disconnected");
-                this.wsClients.delete(ws);
-            });
-            // Handle errors
-            ws.on("error", (error) => {
-                console.error("[WebSocket] Error:", error);
-                this.wsClients.delete(ws);
-            });
-        });
-        this.ws.on("error", (error) => {
-            console.error("[WebSocket] Server error:", error);
-        });
-        this.ws.on("close", () => {
-            console.log("[WebSocket] Server closing...");
-            this.wsClients.clear();
-        });
-    }
-    handleWebSocketMessage(ws, message) {
-        console.log("[WebSocket] Received message:", message.type);
-        // Use WsManager to process the message
-        const response = this.wsManager.processMessage(message.type, message.data, () => this.getProcessSummary(), (processId) => {
-            const processManager = this;
-            if (typeof processManager.getProcessLogs === "function") {
-                return processManager.getProcessLogs(processId);
-            }
-            return [];
-        });
-        // Send the response
-        ws.send(JSON.stringify(response));
-        // For certain message types, we need to perform additional server-side actions
-        // These are side effects that can't be handled by WsManager alone
-        switch (message.type) {
-            case "sourceFilesUpdated":
-                this.handleSourceFilesUpdatedSideEffects(ws, message.data, response);
-                break;
-            case "getBuildListenerState":
-                this.handleGetBuildListenerStateSideEffects(ws);
-                break;
-            case "getBuildEvents":
-                this.handleGetBuildEventsSideEffects(ws);
-                break;
-        }
-    }
-    handleSourceFilesUpdatedSideEffects(ws, data, response) {
-        const { testName, hash, files, runtime } = data || {};
-        if (!testName || !hash || !files || !runtime) {
-            return;
-        }
-        console.log(`[WebSocket] Forwarding source files update to build listener for test: ${testName} (runtime: ${runtime})`);
-        // Check if this instance has sourceFilesUpdated method (inherited from Server_BuildListener)
-        if (typeof this.sourceFilesUpdated === 'function') {
-            console.log(`[WebSocket] sourceFilesUpdated method found, calling it`);
-            try {
-                this.sourceFilesUpdated(testName, hash, files, runtime);
-                console.log(`[WebSocket] sourceFilesUpdated called successfully`);
-                // Broadcast to all clients
-                this.broadcast({
-                    type: "sourceFilesUpdated",
-                    testName,
-                    hash,
-                    files,
-                    runtime,
-                    status: "processed",
-                    timestamp: new Date().toISOString(),
-                    message: "Source files update processed successfully"
-                });
-                // Update the response if successful
-                if (response.status === "success") {
-                    // Response is already sent, but we can send an additional update
-                    ws.send(JSON.stringify({
-                        type: "sourceFilesUpdated",
-                        status: "processed",
-                        testName,
-                        runtime,
-                        message: "Build update processed and broadcasted successfully",
-                        timestamp: new Date().toISOString()
-                    }));
-                }
-            }
-            catch (error) {
-                console.error("[WebSocket] Error processing source files update:", error);
-                // Send error update
-                ws.send(JSON.stringify({
-                    type: "sourceFilesUpdated",
-                    status: "error",
-                    testName,
-                    runtime,
-                    message: `Error processing build update: ${error}`,
-                    timestamp: new Date().toISOString()
-                }));
-            }
-        }
-        else {
-            console.warn("[WebSocket] sourceFilesUpdated method not available on this instance");
-        }
-    }
-    handleGetBuildListenerStateSideEffects(ws) {
-        console.log("[WebSocket] Handling getBuildListenerState request");
-        if (typeof this.getBuildListenerState === 'function') {
-            try {
-                const state = this.getBuildListenerState();
-                ws.send(JSON.stringify({
-                    type: "buildListenerState",
-                    data: state,
-                    timestamp: new Date().toISOString()
-                }));
-            }
-            catch (error) {
-                console.error("[WebSocket] Error getting build listener state:", error);
-                ws.send(JSON.stringify({
-                    type: "buildListenerState",
-                    status: "error",
-                    message: `Error getting build listener state: ${error}`,
-                    timestamp: new Date().toISOString()
-                }));
-            }
-        }
-    }
-    handleGetBuildEventsSideEffects(ws) {
-        console.log("[WebSocket] Handling getBuildEvents request");
-        if (typeof this.getBuildEvents === 'function') {
-            try {
-                const events = this.getBuildEvents();
-                ws.send(JSON.stringify({
-                    type: "buildEvents",
-                    events: events,
-                    timestamp: new Date().toISOString()
-                }));
-            }
-            catch (error) {
-                console.error("[WebSocket] Error getting build events:", error);
-                ws.send(JSON.stringify({
-                    type: "buildEvents",
-                    status: "error",
-                    message: `Error getting build events: ${error}`,
-                    timestamp: new Date().toISOString()
-                }));
-            }
-        }
-    }
-    handleGetProcesses(ws) {
-        if (typeof this.getProcessSummary === 'function') {
-            const summary = this.getProcessSummary();
-            ws.send(JSON.stringify({
-                type: "processes",
-                data: summary,
-                timestamp: new Date().toISOString()
-            }));
-        }
-        else {
-            ws.send(JSON.stringify({
-                type: "processes",
-                data: { processes: [], message: "getProcessSummary not available" },
-                timestamp: new Date().toISOString()
-            }));
-        }
-    }
-}

package/dist/module/src/server/serverManagers/DockerManager.js

@@ -1,28 +0,0 @@
-"use strict";
-// // Do not allow imports from outside the project (fs, exec, ws, etc)
-// import { RUN_TIMES } from "../../runtimes";
-// import { IBuiltConfig, IRunTime } from "../../Types";
-// import { golangBddCommand, golangDockerComposeFile } from "../runtimes/golang/docker";
-// import { javaBddCommand, javaDockerComposeFile } from "../runtimes/java/docker";
-// import { nodeDockerComposeFile, nodeBddCommand } from "../runtimes/node/docker";
-// import { pythonBDDCommand, pythonDockerComposeFile } from "../runtimes/python/docker";
-// import { rubyBddCommand, rubyDockerComposeFile } from "../runtimes/ruby/docker";
-// import { rustBddCommand, rustDockerComposeFile } from "../runtimes/rust/docker";
-// import { webBddCommand, webDockerComposeFile } from "../runtimes/web/docker";
-// export type IService = any;
-// export interface IDockerComposeResult {
-//   exitCode: number;
-//   out: string;
-//   err: string;
-//   data: any;
-// }
-// export class DockerManager {
-//   cwd: string;
-//   composeFile: string;
-//   projectName: string
-//   constructor(composeFile: string, projectName: string) {
-//     this.cwd = process.cwd();
-//     this.composeFile = composeFile
-//     this.projectName = projectName
-//   }
-// }