testeranto 0.219.14 → 0.219.15

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

@@ -1,110 +0,0 @@
-export class HttpManager {
-    routeName(req) {
-        const url = new URL(req.url, `http://${req.headers.host}`);
-        const urlPath = url.pathname;
-        // Extract route name (remove /~/ prefix)
-        return urlPath.slice(3); // Remove '/~/'
-    }
-    decodedPath(req) {
-        const urlPath = new URL(req.url, `http://${req.headers.host}`).pathname;
-        // Prevent directory traversal attacks
-        const decodedPath = decodeURIComponent(urlPath);
-        // Remove leading slash to make it relative
-        return decodedPath.startsWith("/")
-            ? decodedPath.slice(1)
-            : decodedPath;
-    }
-    matchRoute(routeName, routes) {
-        // First, try exact match
-        if (routes && routes[routeName]) {
-            return { handler: routes[routeName], params: {} };
-        }
-        // Then, try pattern matching
-        for (const [pattern, handler] of Object.entries(routes)) {
-            if (pattern.includes(':')) {
-                // Split pattern into parts
-                const patternParts = pattern.split('/');
-                const routeParts = routeName.split('/');
-                // Check if the last pattern part ends with .xml and contains a parameter
-                const lastPatternPart = patternParts[patternParts.length - 1];
-                const isLastParamWithExtension = lastPatternPart.includes(':') && lastPatternPart.includes('.xml');
-                if (isLastParamWithExtension) {
-                    // For patterns like 'process_manager/:runtime/:testname.xml'
-                    let matches = true;
-                    const params = {};
-                    // Match all parts except the last one
-                    for (let i = 0; i < patternParts.length - 1; i++) {
-                        const patternPart = patternParts[i];
-                        const routePart = routeParts[i];
-                        if (patternPart.startsWith(':')) {
-                            // It's a parameter
-                            const paramName = patternPart.slice(1);
-                            params[paramName] = routePart;
-                        }
-                        else if (patternPart !== routePart) {
-                            matches = false;
-                            break;
-                        }
-                    }
-                    if (matches) {
-                        // The last parameter should capture all remaining route parts
-                        const lastParamName = lastPatternPart.slice(1, lastPatternPart.indexOf('.xml'));
-                        const remainingParts = routeParts.slice(patternParts.length - 1);
-                        let paramValue = remainingParts.join('/');
-                        // Remove .xml from the end if present
-                        if (paramValue.endsWith('.xml')) {
-                            paramValue = paramValue.slice(0, -4);
-                        }
-                        params[lastParamName] = paramValue;
-                        return { handler, params };
-                    }
-                }
-                else {
-                    // Original logic for patterns without special handling
-                    if (patternParts.length !== routeParts.length) {
-                        continue;
-                    }
-                    let matches = true;
-                    const params = {};
-                    for (let i = 0; i < patternParts.length; i++) {
-                        const patternPart = patternParts[i];
-                        const routePart = routeParts[i];
-                        if (patternPart.startsWith(':')) {
-                            // It's a parameter
-                            const paramName = patternPart.slice(1);
-                            params[paramName] = routePart;
-                        }
-                        else if (patternPart !== routePart) {
-                            matches = false;
-                            break;
-                        }
-                    }
-                    if (matches) {
-                        return { handler, params };
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    extractParams(pattern, routeName) {
-        const patternParts = pattern.split('/');
-        const routeParts = routeName.split('/');
-        if (patternParts.length !== routeParts.length) {
-            return null;
-        }
-        const params = {};
-        for (let i = 0; i < patternParts.length; i++) {
-            const patternPart = patternParts[i];
-            const routePart = routeParts[i];
-            if (patternPart.startsWith(':')) {
-                const paramName = patternPart.slice(1);
-                params[paramName] = routePart;
-            }
-            else if (patternPart !== routePart) {
-                return null;
-            }
-        }
-        return params;
-    }
-}

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

@@ -1,226 +0,0 @@
-export class WsManager {
-    constructor() { }
-    escapeXml(unsafe) {
-        if (!unsafe)
-            return '';
-        return unsafe.replace(/[<>&'"]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-                case '\'': return '&apos;';
-                case '"': return '&quot;';
-                default: return c;
-            }
-        });
-    }
-    // Process message and return response data
-    processMessage(type, data, getProcessSummary, getProcessLogs) {
-        console.log("[WsManager] Processing message:", type);
-        switch (type) {
-            case "ping":
-                return {
-                    type: "pong",
-                    timestamp: new Date().toISOString()
-                };
-            case "getProcesses":
-                if (getProcessSummary) {
-                    const summary = getProcessSummary();
-                    return {
-                        type: "processes",
-                        data: summary,
-                        timestamp: new Date().toISOString()
-                    };
-                }
-                else {
-                    return {
-                        type: "processes",
-                        data: { processes: [], totalProcesses: 0, running: 0 },
-                        timestamp: new Date().toISOString()
-                    };
-                }
-            case "getLogs":
-                const { processId } = data || {};
-                if (!processId) {
-                    return {
-                        type: "logs",
-                        status: "error",
-                        message: "Missing processId",
-                        timestamp: new Date().toISOString()
-                    };
-                }
-                if (getProcessLogs) {
-                    const logs = getProcessLogs(processId);
-                    return {
-                        type: "logs",
-                        processId,
-                        logs: logs.map((log) => {
-                            let level = "info";
-                            let source = "process";
-                            let message = log;
-                            const match = log.match(/\[(.*?)\] \[(.*?)\] (.*)/);
-                            if (match) {
-                                const timestamp = match[1];
-                                source = match[2];
-                                message = match[3];
-                                if (source === "stderr" || source === "error") {
-                                    level = "error";
-                                }
-                                else if (source === "warn") {
-                                    level = "warn";
-                                }
-                                else if (source === "debug") {
-                                    level = "debug";
-                                }
-                                else {
-                                    level = "info";
-                                }
-                            }
-                            return {
-                                timestamp: new Date().toISOString(),
-                                level: level,
-                                message: message,
-                                source: source
-                            };
-                        }),
-                        timestamp: new Date().toISOString()
-                    };
-                }
-                else {
-                    return {
-                        type: "logs",
-                        processId,
-                        logs: [],
-                        timestamp: new Date().toISOString()
-                    };
-                }
-            case "subscribeToLogs":
-                const { processId: subProcessId } = data || {};
-                if (!subProcessId) {
-                    return {
-                        type: "logSubscription",
-                        status: "error",
-                        message: "Missing processId",
-                        timestamp: new Date().toISOString()
-                    };
-                }
-                return {
-                    type: "logSubscription",
-                    status: "subscribed",
-                    processId: subProcessId,
-                    timestamp: new Date().toISOString()
-                };
-            case "sourceFilesUpdated":
-                const { testName, hash, files, runtime } = data || {};
-                if (!testName || !hash || !files || !runtime) {
-                    return {
-                        type: "sourceFilesUpdated",
-                        status: "error",
-                        message: "Missing required fields: testName, hash, files, or runtime",
-                        timestamp: new Date().toISOString()
-                    };
-                }
-                // Note: Actual processing needs to be done by the server
-                return {
-                    type: "sourceFilesUpdated",
-                    status: "success",
-                    testName,
-                    runtime,
-                    message: "Build update processed successfully",
-                    timestamp: new Date().toISOString()
-                };
-            case "getBuildListenerState":
-                // This needs server-side implementation
-                return {
-                    type: "buildListenerState",
-                    status: "error",
-                    message: "Build listener state not available",
-                    timestamp: new Date().toISOString()
-                };
-            case "getBuildEvents":
-                // This needs server-side implementation
-                return {
-                    type: "buildEvents",
-                    status: "error",
-                    message: "Build events not available",
-                    timestamp: new Date().toISOString()
-                };
-            default:
-                return {
-                    type: "error",
-                    message: `Unknown message type: ${type}`,
-                    timestamp: new Date().toISOString()
-                };
-        }
-    }
-    // Helper methods for specific message types
-    getProcessesResponse(processSummary) {
-        return {
-            type: "processes",
-            data: processSummary,
-            timestamp: new Date().toISOString()
-        };
-    }
-    getLogsResponse(processId, logs) {
-        return {
-            type: "logs",
-            processId,
-            logs: logs.map((log) => {
-                let level = "info";
-                let source = "process";
-                let message = log;
-                const match = log.match(/\[(.*?)\] \[(.*?)\] (.*)/);
-                if (match) {
-                    const timestamp = match[1];
-                    source = match[2];
-                    message = match[3];
-                    if (source === "stderr" || source === "error") {
-                        level = "error";
-                    }
-                    else if (source === "warn") {
-                        level = "warn";
-                    }
-                    else if (source === "debug") {
-                        level = "debug";
-                    }
-                    else {
-                        level = "info";
-                    }
-                }
-                return {
-                    timestamp: new Date().toISOString(),
-                    level: level,
-                    message: message,
-                    source: source
-                };
-            }),
-            timestamp: new Date().toISOString()
-        };
-    }
-    getSourceFilesUpdatedResponse(testName, runtime, status, message) {
-        return {
-            type: "sourceFilesUpdated",
-            status,
-            testName,
-            runtime,
-            message: message || "Build update processed successfully",
-            timestamp: new Date().toISOString()
-        };
-    }
-    getErrorResponse(type, errorMessage) {
-        return {
-            type: type,
-            status: "error",
-            message: errorMessage,
-            timestamp: new Date().toISOString()
-        };
-    }
-    getSuccessResponse(type, data) {
-        return {
-            type: type,
-            status: "success",
-            data: data,
-            timestamp: new Date().toISOString()
-        };
-    }
-}

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

@@ -1,32 +0,0 @@
-"use strict";
-// // Do not allow imports from outside the project
-// const getBaseHtml = (title: string) => `
-// <!DOCTYPE html>
-// <html lang="en">
-// <head>
-//   <meta name="description" content="Webpage description goes here" />
-//   <meta charset="utf-8" />
-//   <title>${title} - testeranto</title>
-//   <meta name="viewport" content="width=device-width, initial-scale=1" />
-//   <meta name="author" content="" />
-// `;
-// export const ProcessMangerHtml = () => `
-//   ${getBaseHtml("Testeranto")}
-//   <link rel="stylesheet" href="ProcessManger.css" />
-//   <script src="ProcessManger.js"></script>
-// </head>
-// <body>
-//   <div id="root"></div>
-// </body>
-// </html>
-// `;
-// export const IndexHtml = () => `
-//   ${getBaseHtml("Testeranto")}
-//   <link rel="stylesheet" href="Index.css" />
-//   <script src="Index.js"></script>
-// </head>
-// <body>
-//   <div id="root"></div>
-// </body>
-// </html>
-// `;

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

@@ -1,47 +0,0 @@
-// Do not allow imports from outside the project
-/**
- * Constants for Server_TCP configuration
- */
-export const SERVER_CONSTANTS = {
-    HOST: "0.0.0.0",
-};
-export const CONTENT_TYPES = {
-    PLAIN: "text/plain",
-    HTML: "text/html",
-    JAVASCRIPT: "application/javascript",
-    CSS: "text/css",
-    JSON: "application/json",
-    PNG: "image/png",
-    JPEG: "image/jpeg",
-    GIF: "image/gif",
-    SVG: "image/svg+xml",
-    ICO: "image/x-icon",
-    WOFF: "font/woff",
-    WOFF2: "font/woff2",
-    TTF: "font/ttf",
-    EOT: "application/vnd.ms-fontobject",
-    XML: "application/xml",
-    PDF: "application/pdf",
-    ZIP: "application/zip",
-    OCTET_STREAM: "application/octet-stream",
-};
-export function getContentType(filePath) {
-    if (filePath.endsWith(".html"))
-        return CONTENT_TYPES.HTML;
-    else if (filePath.endsWith(".js") || filePath.endsWith(".mjs"))
-        return CONTENT_TYPES.JAVASCRIPT;
-    else if (filePath.endsWith(".css"))
-        return CONTENT_TYPES.CSS;
-    else if (filePath.endsWith(".json"))
-        return CONTENT_TYPES.JSON;
-    else if (filePath.endsWith(".png"))
-        return CONTENT_TYPES.PNG;
-    else if (filePath.endsWith(".jpg") || filePath.endsWith(".jpeg"))
-        return CONTENT_TYPES.JPEG;
-    else if (filePath.endsWith(".gif"))
-        return CONTENT_TYPES.GIF;
-    else if (filePath.endsWith(".svg"))
-        return CONTENT_TYPES.SVG;
-    else
-        return CONTENT_TYPES.PLAIN;
-}

package/dist/module/src/server/types.js

@@ -1 +0,0 @@
-export {};

package/dist/module/src/testeranto.js

@@ -1,40 +0,0 @@
-const fs = await import('fs/promises');
-// const yaml = await import('yaml');
-// import path from "path";
-import { Server } from "./server/serverClasees/Server";
-const mode = process.argv[3];
-if (mode !== "once" && mode !== "dev") {
-    console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
-    process.exit(-1);
-}
-const main = async () => {
-    // const yamlPath = path.join(process.cwd(), 'testeranto/testeranto.yml');
-    // const yamlContent = await fs.readFile(yamlPath, 'utf-8');
-    // const parsed = yaml.parse(yamlContent);
-    // const config: ITestconfigV2 = new Map();
-    // for (const [key, value] of Object.entries(parsed)) {
-    //   if (Array.isArray(value) && value.length >= 4) {
-    //     // The first three elements are runtime, dockerfile, script
-    //     const runtime = String(value[0]) as IRunTime;
-    //     const dockerfile = String(value[1]);
-    //     const script = String(value[2]);
-    //     // The fourth element should be an object with tests
-    //     let testsObj = { tests: [] as string[] };
-    //     const fourth = value[3];
-    //     if (fourth && typeof fourth === 'object' && fourth !== null) {
-    //       const testsData = fourth as any;
-    //       if (testsData.tests && Array.isArray(testsData.tests)) {
-    //         testsObj.tests = testsData.tests.map((t: any) => String(t));
-    //       }
-    //     }
-    //     config.set(key, [runtime, dockerfile, script, testsObj]);
-    //   } else {
-    //     console.warn(`Skipping entry ${key}: expected array with at least 4 elements, got`, value);
-    //   }
-    // }
-    // console.log('Parsed config:', Array.from(config.entries()));
-    const config = (await import('../testeranto/testeranto.ts')).default;
-    console.log("mark123", config);
-    await new Server(config, mode).start();
-};
-main();

package/dist/module/src/vscode/TerminalManager.js

@@ -1,92 +0,0 @@
-import * as vscode from 'vscode';
-export class TerminalManager {
-    constructor() {
-        this.terminals = new Map();
-    }
-    getTerminalKey(runtime, testName) {
-        return `${runtime}:${testName}`;
-    }
-    createTerminal(runtime, testName) {
-        const key = this.getTerminalKey(runtime, testName);
-        const terminal = vscode.window.createTerminal(`Testeranto: ${testName} (${runtime})`);
-        this.terminals.set(key, terminal);
-        return terminal;
-    }
-    getTerminal(runtime, testName) {
-        const key = this.getTerminalKey(runtime, testName);
-        return this.terminals.get(key);
-    }
-    showTerminal(runtime, testName) {
-        const terminal = this.getTerminal(runtime, testName);
-        if (terminal) {
-            terminal.show();
-        }
-        return terminal;
-    }
-    sendTextToTerminal(runtime, testName, text) {
-        const terminal = this.getTerminal(runtime, testName);
-        if (terminal) {
-            terminal.sendText(text);
-        }
-    }
-    disposeTerminal(runtime, testName) {
-        const key = this.getTerminalKey(runtime, testName);
-        const terminal = this.terminals.get(key);
-        if (terminal) {
-            terminal.dispose();
-            this.terminals.delete(key);
-        }
-    }
-    disposeAll() {
-        for (const terminal of this.terminals.values()) {
-            terminal.dispose();
-        }
-        this.terminals.clear();
-    }
-    getAllTestConfigs() {
-        const configs = [];
-        const runtimes = ["node", "web", "python", "golang"];
-        for (const runtime of runtimes) {
-            let testNames = [];
-            switch (runtime) {
-                case "node":
-                    testNames = ["Calculator.test.ts"];
-                    break;
-                case "web":
-                    testNames = ["Calculator.test.ts"];
-                    break;
-                case "python":
-                    testNames = ["Calculator.pitono.test.py"];
-                    break;
-                case "golang":
-                    testNames = ["Calculator.golingvu.test.go"];
-                    break;
-            }
-            for (const testName of testNames) {
-                configs.push({ runtime, testName });
-            }
-        }
-        return configs;
-    }
-    createAiderTerminal(runtime, testName) {
-        const key = this.getTerminalKey(runtime, testName);
-        let terminal = this.terminals.get(key);
-        if (terminal && terminal.exitStatus === undefined) {
-            return terminal;
-        }
-        terminal = vscode.window.createTerminal(`Aider: ${testName} (${runtime})`);
-        this.terminals.set(key, terminal);
-        return terminal;
-    }
-    createAllTerminals() {
-        const configs = this.getAllTestConfigs();
-        for (const { runtime, testName } of configs) {
-            try {
-                this.createTerminal(runtime, testName);
-            }
-            catch (error) {
-                console.error(`Failed to create terminal for ${testName} (${runtime}):`, error);
-            }
-        }
-    }
-}

package/dist/module/src/vscode/TestTreeItem.js

@@ -1,40 +0,0 @@
-import * as vscode from 'vscode';
-import { TreeItemType } from './types';
-export class TestTreeItem extends vscode.TreeItem {
-    constructor(label, type, collapsibleState, data, command, iconPath) {
-        super(label, collapsibleState);
-        this.label = label;
-        this.type = type;
-        this.collapsibleState = collapsibleState;
-        this.data = data;
-        this.command = command;
-        this.iconPath = iconPath;
-        this.tooltip = `${this.label}`;
-        this.iconPath = iconPath || this.getDefaultIcon();
-        this.contextValue = this.getContextValue();
-    }
-    getDefaultIcon() {
-        switch (this.type) {
-            case TreeItemType.Runtime:
-                return new vscode.ThemeIcon("symbol-namespace");
-            case TreeItemType.Test:
-                return new vscode.ThemeIcon("beaker");
-            case TreeItemType.File:
-                return new vscode.ThemeIcon("file");
-            default:
-                return undefined;
-        }
-    }
-    getContextValue() {
-        switch (this.type) {
-            case TreeItemType.Runtime:
-                return 'runtimeItem';
-            case TreeItemType.Test:
-                return 'testItem';
-            case TreeItemType.File:
-                return 'fileItem';
-            default:
-                return 'unknown';
-        }
-    }
-}