@codenotch/codenotch.cli 1.0.33 → 1.0.34

package/src/utils/RuntimeUtils.ts

@@ -1,743 +0,0 @@
-
-import os, { version } from "node:os";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-import { pipeline } from "node:stream/promises";
-import { Readable } from "node:stream";
-import { spawn } from "node:child_process";
-import chalk from "chalk";
-import decompress from "decompress";
-import { IProcessTestReport, IScenarioProjectManifest, ProjectState } from "../models/Codenotch";
-import FileUtils from "./FileUtils";
-import ProjectUtils from "./ProjectUtils";
-import GitHubAuthUtils from "./GitHubAuthUtils";
-import ProjectCompilationUtils from "./ProjectCompilationUtils";
-
-type RuntimeMeta = {
-    host: string;
-    port: number;
-    version?: string;
-    dataPath?: string;
-};
-
-export default abstract class RuntimeUtils {
-
-    /// The directory where the runtime is installed, we will store the executable and other files there
-    /// TODO not sure about that, should we store globally, or for each "project" ? Both ? like npm
-    static readonly CODENOTCH_INSTALL_DIR = process.env.CODENOTCH_PATH?.trim()
-        ? path.resolve(process.env.CODENOTCH_PATH.trim())
-        : path.join(os.homedir(), ".codenotch"); 
-    static readonly CODENOTCH_DATA_FOLDER = "data";
-    private static readonly RUNTIME_PID_FILE = path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, "runtime.pid");
-    private static readonly RUNTIME_META_FILE = path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, "runtime.json");
-    private static readonly DEFAULT_RUNTIME_HOST = "127.0.0.1";
-    private static readonly DEFAULT_RUNTIME_PORT = 5005;
-    private static readonly ADMIN_USER_EMAIL = "admin@example.com";
-
-    //#region Runtime 
-
-    private static async readRuntimeMeta(): Promise<RuntimeMeta | null> {
-        try {
-            const raw = await fs.readFile(RuntimeUtils.RUNTIME_META_FILE, "utf8");
-            return JSON.parse(raw) as RuntimeMeta;
-        } catch {
-            return null;
-        }
-    }
-
-    private static async writeRuntimeMeta(meta: RuntimeMeta): Promise<void> {
-        await fs.mkdir(RuntimeUtils.CODENOTCH_INSTALL_DIR, { recursive: true });
-        await fs.writeFile(RuntimeUtils.RUNTIME_META_FILE, JSON.stringify(meta, null, 2), "utf8");
-    }
-
-    static async getRuntimeBaseUrl(): Promise<string> {
-
-        //return `http://localhost:5002`; // for testing on local visual studio 
-
-        const meta = await RuntimeUtils.readRuntimeMeta();
-        const host = meta?.host ?? RuntimeUtils.DEFAULT_RUNTIME_HOST;
-        const port = meta?.port ?? RuntimeUtils.DEFAULT_RUNTIME_PORT;
-        return `http://${host}:${port}`;
-    }
-
-    static async runtimeFetch<T>(path: string, includeToken: boolean = false, options?: RequestInit): Promise<T> {
-
-        const baseUrl = await RuntimeUtils.getRuntimeBaseUrl();
-        const isFormData = options?.body instanceof FormData;
-
-        let finalOptions: RequestInit = {
-            ...options,
-            credentials: 'include',
-            headers: {
-            ...(isFormData ? {} : { 'Content-Type': 'application/json' }),
-            ...options?.headers,
-            }
-        };
-
-        if (includeToken) {
-            const token = await RuntimeUtils.getAdminToken();
-            (finalOptions.headers as any)["devAccessToken"] = token;
-        }
-
-        const url = `${baseUrl}${path}`;
-        const res = await fetch(url, finalOptions);
-        if (!res.ok) {
-            const body = await res.text().catch(() => null);
-            throw new Error(`Runtime api error: ${url} -> ${res.status} - ${body}`);
-        }
-
-        if (res.status === 204 || res.headers.get('content-length') === '0') {
-            return undefined as T;
-        }
-
-        let content = await res.text();
-
-        try{
-            return JSON.parse(content) as T;
-        }
-        catch(e) {
-            return content as unknown as T;
-        }
-    }
-
-    private static async getAdminToken(): Promise<string> {
-
-        // Use the client_credentials flow to get an admin token
-        // In dev/local the flow we only need the user email to issue a token
-        var response = await RuntimeUtils.runtimeFetch<{access_token: string}>(`/_auth/token`, false, {
-
-            method: "POST",
-            body: new URLSearchParams({
-                client_id: RuntimeUtils.ADMIN_USER_EMAIL,
-                grant_type: "client_credentials",
-            }),
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded"
-            }
-        });
-
-        //TODO some way to cache and reuse this
-
-        return response.access_token;
-    }
-
-    static async ensureRuntimeInstalled(): Promise<void> {
-        
-        const isInstalled = await RuntimeUtils.isRuntimeInstalled();
-        if (!isInstalled) {
-
-            //TODO Here we assume NodeJs is installed and available in PATH, we should check that and propose to install it if not
-            await RuntimeUtils.installLatestRuntime();
-        }
-    }
-
-    static async ensureRuntimeIsRunning(): Promise<void> {
-        
-        const isRunning = await RuntimeUtils.isRuntimeRunning();
-        if (isRunning) {
-            return;
-        }
-
-        await RuntimeUtils.startRuntime();
-    }
-
-    static async isRuntimeInstalled(): Promise<boolean> {
-        const targetExe = RuntimeUtils.getRuntimeExecutablePath();
-        try {
-            await fs.access(targetExe);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    static async isRuntimeRunning(): Promise<boolean> {
-        try {
-            const pidStr = await fs.readFile(RuntimeUtils.RUNTIME_PID_FILE, "utf8");
-            const pid = parseInt(pidStr.trim());
-            
-            if (isNaN(pid)) {
-                return false;
-            }
-
-            // Check if process exists by sending signal 0 (doesn't kill, just checks)
-            try {
-                process.kill(pid, 0);
-                return true;
-            } catch {
-                // Process doesn't exist
-                await fs.unlink(RuntimeUtils.RUNTIME_PID_FILE).catch(() => {});
-                return false;
-            }
-        } catch {
-            // PID file doesn't exist
-            return false;
-        }
-    }
-
-    static async runRuntimeExecutable(args: string[] = [], detached: boolean, envVars: { [key: string]: string } = {}): Promise<string> {
-        
-        const exePath = RuntimeUtils.getRuntimeExecutablePath();
-
-        try {
-            const child = spawn(exePath, args, {
-                detached: detached,
-                stdio: detached ? "ignore" : "pipe",
-                windowsHide: true,
-                env: { ...process.env, ...envVars },
-            });
-
-            if (detached) {
-                // Store the PID for later reference
-                await fs.mkdir(RuntimeUtils.CODENOTCH_INSTALL_DIR, { recursive: true });
-                await fs.writeFile(RuntimeUtils.RUNTIME_PID_FILE, child.pid!.toString());
-                child.unref(); // Allow parent process to exit independently
-                return "";
-            } else {
-                // Wait for the child process to complete
-                let stdout = "";
-                let stderr = "";
-
-                child.stdout?.on("data", (chunk) => {
-                    const text = chunk.toString();
-                    stdout += text;
-                    process.stdout.write(text);
-                });
-
-                child.stderr?.on("data", (chunk) => {
-                    const text = chunk.toString();
-                    stderr += text;
-                    process.stderr.write(text);
-                });
-
-                await new Promise<void>((resolve, reject) => {
-                    child.on("exit", (code) => {
-                        if (code === 0) {
-                            resolve();
-                        } else {
-                            const errorOutput = stderr.trim() || stdout.trim();
-                            reject(new Error(`Runtime process exited with code ${code}${errorOutput ? `: ${errorOutput}` : ""}`));
-                        }
-                    });
-                    child.on("error", reject);
-                });
-
-                return stdout.trim();
-            }
-        } catch (error) {
-            throw new Error(`Failed to run runtime executable: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-
-    static getRuntimeExecutablePath(): string {
-        const platform = process.platform; // win32 | linux | darwin
-        const exeName = platform === "win32" ? "codenotch.exe" : "codenotch";
-        return path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, exeName);
-    }
-
-    static async installLatestRuntime(): Promise<void> {
-
-        let wasRunning = await RuntimeUtils.isRuntimeRunning();
-        if(wasRunning) {
-            await RuntimeUtils.stopRuntime();
-        }
-
-        const platform = process.platform; // win32 | linux | darwin
-        const exeName = platform === "win32" ? "codenotch.exe" : "codenotch";
-
-        let assetName;
-        if (platform === "win32") assetName = "codenotch-windows.zip";
-        else if (platform === "linux") assetName = "codenotch-linux.tar.gz";
-        else if (platform === "darwin") assetName = "codenotch-macos.tar.gz";
-        else throw new Error(`Unsupported platform: ${platform}`);
-
-        // We need to authenticate because the repo is private
-        const token = await GitHubAuthUtils.getToken();
-        const headers = {
-            Authorization: `Bearer ${token}`,
-        };
-
-        console.log(chalk.blue(`Getting latest Codenotch runtime release metadata...`));
-        const latestReleaseRes = await fetch(
-            "https://api.github.com/repos/EchinoHub/service-core/releases/latest",
-            { 
-                headers: {
-                    ...headers,
-                    "Accept": "application/vnd.github+json"
-                } 
-            }
-        );
-
-        if (!latestReleaseRes.ok) {
-            const body = await latestReleaseRes.text().catch(() => "");
-            throw new Error(`Failed to get latest release: ${latestReleaseRes.status} ${body}`);
-        }
-
-        //const url = `https://github.com/EchinoHub/service-core/releases/latest/download/${assetName}`;
-
-        const release = await latestReleaseRes.json() as any;
-        const asset = release.assets.find((a: any) => a.name === assetName);
-
-        if (!asset) {
-            throw new Error(
-                `Asset not found: ${assetName}.`
-            );
-        }
-
-        const version = release.tag_name;
-
-        console.log(chalk.blue(`Downloading Codenotch runtime from ${asset.url}...`));
-        const res = await fetch(asset.url, { 
-            redirect: "follow",
-            headers: {
-                    ...headers,
-                    "Accept": "application/octet-stream"
-                }  
-        });
-        if (!res.ok || !res.body) {
-            console.log(chalk.red(`Failed to download runtime from ${asset.url}`));
-            throw new Error(`Download failed: ${res.status} ${res.statusText}`);
-        }
-
-        const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codenotch-"));
-        try
-        {
-            const archivePath = path.join(tempRoot, assetName);
-            const extractDir = path.join(tempRoot, "extract");
-
-            await fs.mkdir(RuntimeUtils.CODENOTCH_INSTALL_DIR, { recursive: true });
-            await fs.mkdir(extractDir, { recursive: true });
-
-            await pipeline(Readable.fromWeb(res.body), createWriteStream(archivePath));
-            await decompress(archivePath, extractDir);
-
-            const downloadedExe = path.join(extractDir, assetName.split(".")[0], exeName);
-            const targetExe = path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, exeName);
-            await fs.copyFile(downloadedExe, targetExe);
-            if (platform !== "win32") await fs.chmod(targetExe, 0o755);
-
-            // Update the metadata with the version
-            const existingMeta = await RuntimeUtils.readRuntimeMeta();
-            await RuntimeUtils.writeRuntimeMeta({
-                host: existingMeta?.host ?? RuntimeUtils.DEFAULT_RUNTIME_HOST,
-                port: existingMeta?.port ?? RuntimeUtils.DEFAULT_RUNTIME_PORT,
-                version: version,
-                dataPath: existingMeta?.dataPath
-            });
-
-            console.log(chalk.blue(`The runtime has been installed successfully.`));
-        }
-        finally {
-            FileUtils.delete(tempRoot);
-        }
-
-        if(wasRunning) {
-            await RuntimeUtils.startRuntime();
-        }
-    }
-
-    static async startRuntime(options?: { port?: number, attach?: boolean, dataPath?: string }): Promise<void> {
-
-        const isRunning = await RuntimeUtils.isRuntimeRunning();
-        if (isRunning) {
-            return;
-        }
-
-        await this.ensureRuntimeInstalled();
-
-        // Start the runtime process in detached mode by default
-        let detached = true;
-        if(options?.attach) {
-            detached = false;
-        }
-
-        console.log(chalk.blue(`Starting Codenotch runtime ${detached ? "in detached mode" : "in attached mode"}...`));
-        const port = options?.port ?? RuntimeUtils.DEFAULT_RUNTIME_PORT;
-        const dataPath = options?.dataPath;
-
-        const version = await RuntimeUtils.getRuntimeVersion();
-
-        // Store the runtime meta (like the port) so we can use it later to connect to the runtime
-        await RuntimeUtils.writeRuntimeMeta({
-            host: RuntimeUtils.DEFAULT_RUNTIME_HOST,
-            port: port,
-            version: version,
-            dataPath: dataPath
-        });
-
-        const runtimeArgs = dataPath ? ["-d", dataPath] : [];
-        await RuntimeUtils.runRuntimeExecutable(runtimeArgs, detached, { CODENOTCH_PORT: String(port), START_URL: '' }); // pass the port and prevent the runtime from opening the browser automatically
-
-        // Wait until the runtime is responsive
-        const maxAttempts = 50; // Wait up to 10 seconds
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            try {
-                await RuntimeUtils.runtimeFetch("/health");
-                console.log(chalk.green(`Runtime is ready!`));
-                return; // Runtime is responsive
-            } catch(e) {
-                await new Promise(resolve => setTimeout(resolve, 200));
-                attempts++;
-            }
-        }
-
-        console.log(chalk.red(`Failed to start runtime: runtime did not become responsive within expected time.`));
-        throw new Error(`Runtime did not become responsive within expected time.`);
-    }
-
-    static async stopRuntime(): Promise<void> {
-
-        if(await RuntimeUtils.isRuntimeInstalled() === false) {
-            return;
-        }
-
-        if(await RuntimeUtils.isRuntimeRunning() === false) {
-            return;
-        }
-
-        try {
-            const pidStr = await fs.readFile(RuntimeUtils.RUNTIME_PID_FILE, "utf8");
-            const pid = parseInt(pidStr.trim());
-            
-            if (!isNaN(pid)) {
-                // Send SIGTERM to gracefully stop the process
-                process.kill(pid, "SIGTERM");
-                
-                // Wait up to 5 seconds for graceful shutdown
-                let attempts = 0;
-                while (attempts < 50 && await RuntimeUtils.isRuntimeRunning()) {
-                    await new Promise(resolve => setTimeout(resolve, 100));
-                    attempts++;
-                }
-                
-                // If still running, force kill
-                if (await RuntimeUtils.isRuntimeRunning()) {
-                    process.kill(pid, "SIGKILL");
-                    await new Promise(resolve => setTimeout(resolve, 100));
-                }
-            }
-            
-            // Clean up the PID file
-            await fs.unlink(RuntimeUtils.RUNTIME_PID_FILE).catch(() => {});
-        } catch (error) {
-            throw new Error(`Failed to stop runtime: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-
-    static async clearRuntime(): Promise<void> {
-
-        // Remove the runtime data folder, but keep the executable and other files
-        const dataDir = path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, RuntimeUtils.CODENOTCH_DATA_FOLDER);
-        try {
-            await fs.rm(dataDir, { recursive: true, force: true });
-            console.log(chalk.green(`Runtime data cleared successfully.`));
-        } catch (error) {
-            console.log(chalk.red(`Failed to clear runtime data: ${error}`));
-            throw error;
-        }
-    }
-
-    static async getRuntimeVersion(): Promise<string> {
-
-        if(!await RuntimeUtils.isRuntimeInstalled()) {
-            return "Not installed";
-        }
-
-        // Use the metadata if available to avoid calling the executable, which can be slow to start
-        const meta = await RuntimeUtils.readRuntimeMeta();
-
-        if(!meta?.version) {
-            return await RuntimeUtils.runRuntimeExecutable(["--version"], false);
-        }
-    
-        return meta?.version;
-    }
-
-    static async getRuntimeDataPath(): Promise<string | undefined> {
-        const meta = await RuntimeUtils.readRuntimeMeta();
-        return meta?.dataPath;
-    }
-
-    static async getLatestRuntimeRelease(): Promise<{version: string, createdAt: string, url: string}> {
-        const token = await GitHubAuthUtils.getToken();
-        const headers: Record<string, string> = {
-            "Accept": "application/vnd.github+json",
-            "Authorization": `Bearer ${token}`,
-        };
-
-        const res = await fetch(
-            "https://api.github.com/repos/EchinoHub/service-core/releases/latest",
-            { headers }
-        );
-
-        if (!res.ok) {
-            const body = await res.text().catch(() => "");
-            throw new Error(`Failed to get latest release: ${res.status} ${body}`);
-        }
-
-        const release = await res.json() as any;
-        return {
-            version: release.tag_name,
-            createdAt: release.created_at,
-            url: release.html_url
-        }
-    }
-
-    //#endregion
-
-    //#region Project management
-
-    static async startProject(projectPath: string): Promise<void> {
-
-        //TODO multiproject support
-        //TODO --watch mode
-
-        const serviceName = await ProjectUtils.getProjectServiceName(projectPath);
-
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
-
-        const outputPath = path.join(os.tmpdir(), `cn-build-${Date.now()}.zip`);
-
-        try
-        {
-            console.log(chalk.blue(`Building project "${serviceName}"...`));
-            await ProjectUtils.packageProject(projectPath, outputPath, true);
-            console.log(chalk.blue(`Deploying project "${serviceName}" to runtime...`));
-            await new Promise(resolve => setTimeout(resolve, 2000)); // Wait a bit before deploying to ensure the runtime is fully ready, only temporary until runtime fix the ready endpoint to be more reliable
-            var deploySuccess = await RuntimeUtils.deployProject(serviceName, outputPath);
-            if (deploySuccess) {
-                console.log(chalk.green(`Project "${serviceName}" is now running.`));
-            } else {
-                console.log(chalk.red(`Project start failed.`));
-            }
-        }
-        finally {
-            // Remove the build
-            FileUtils.delete(outputPath);
-        }
-    }
-
-    static async testProject(projectPath: string, fileFilter?: string, nameFilter?: string, inPlace: boolean = false): Promise<void> {
-
-        await RuntimeUtils.ensureRuntimeInstalled();
-
-        // For testing we use a separate instance of the runtime
-        // We run it in attach mode so we get the results in the console
-        const isPartial = !!(fileFilter || nameFilter);
-        const finalReportPath = path.join(projectPath, "test-report.json");
-
-        // Runs the runtime test command, writing the report to a given path via -r
-        const testFunc = async (workPath: string, reportPath: string) =>
-            await RuntimeUtils.runRuntimeExecutable([
-                "test",
-                "-p", workPath,
-                ...(fileFilter ? ["-f", fileFilter] : []),
-                ...(nameFilter ? ["-t", nameFilter] : []),
-                "-r", reportPath,
-            ], false);
-
-        // To test a project, we need to install it and to install it, we need it to be compiled
-        let projectCompiled = await ProjectUtils.isManifestCompiled(projectPath);
-
-        // If the project is already compiled we can go ahead and test it
-        if (projectCompiled) {
-            const tempReportPath = path.join(os.tmpdir(), `cn-report-${Date.now()}.json`);
-            try {
-                await testFunc(projectPath, tempReportPath);
-                await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
-            } finally {
-                await fs.unlink(tempReportPath).catch(() => {});
-            }
-            return;
-        }
-
-        // We need a "lightly-compiled" project, meaning we need a full manifest (we don't need i18n or to build the React apps) 
-        let compileFunc = async (path: string) => {
-            const compilation = await ProjectCompilationUtils.compileTestProject(path);
-
-            if(compilation.errors.length > 0) {
-                console.error(chalk.red("Compilation failed with errors:"));
-                compilation.errors.forEach(err => console.error(chalk.red(`- ${err}`)));
-                console.warn(chalk.yellow("Ignoring compilation errors and proceeding with testing..."));
-            }
-        };
-
-        // In-place means we can compile and modify files directly in the project folder, we don't need to copy them to a temp folder, this is useful during CI/CD
-        // Inside the IDE we'll prefer to copy the folder to avoid modifying the source files
-
-        if (inPlace) {
-            await compileFunc(projectPath);
-            const tempReportPath = path.join(os.tmpdir(), `cn-report-${Date.now()}.json`);
-            try {
-                await testFunc(projectPath, tempReportPath);
-                await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
-            } finally {
-                await fs.unlink(tempReportPath).catch(() => {});
-            }
-            return;
-        }
-
-        const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codenotch-"));
-        try
-        {
-            // Copy project
-            await FileUtils.copyFolder(projectPath, tempRoot, ['.git', 'node_modules', 'dist', 'build', 'out']);
-            await compileFunc(tempRoot);
-            const tempReportPath = path.join(tempRoot, "test-report.json");
-            await testFunc(tempRoot, tempReportPath);
-            await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
-        }
-        finally {
-            // Clean up temp folder
-            //TODO consider keeping it for faster re-testing if project has not changed
-            await FileUtils.delete(tempRoot);
-        }
-    }
-
-    static async deployProject(serviceName: string, packagePath: string): Promise<boolean> {
-
-        // We assume the project is already built and packaged, we just need to deploy it to the runtime
-
-        // Get the information about the project package, we assume it's in the current directory and named "project.zip"
-        const zipFilePath = packagePath;
-        try {
-            await fs.access(zipFilePath);
-        } catch (error) {
-            console.log(chalk.red(`Project package not found: ${zipFilePath}`));
-            throw new Error(`Project package not found: ${zipFilePath}`);
-        }
-
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
-
-        const zipBuffer = await fs.readFile(zipFilePath);
-        const zipBlob = new Blob([zipBuffer], { type: "application/zip" });
-
-        const form = new FormData();
-        form.append('serviceName', serviceName);
-        form.append('file', zipBlob, "package.zip");
-        await RuntimeUtils.runtimeFetch("/project/upload", true, {
-            method: "POST",
-            body: form
-        });
-
-        // Wait until the project deployment has completed
-        while (true) {
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            try {
-                const projectState = await RuntimeUtils.runtimeFetch<ProjectState>(`/${serviceName}/project`, true);
-                if(projectState.status === "READY")
-                {
-                    console.log(chalk.green(`${serviceName} is ready!`));
-                    return true;
-                }
-                else if(projectState.status === "FAILURE" || projectState.status === "REMOVING")
-                {
-                    console.log(chalk.red(`Failed to deploy ${serviceName}. Errors: ${projectState.errors?.join(", ")}`));
-                    return false;
-                }
-            } catch {
-                // Keep waiting
-            }
-        }
-    }
-
-    static async patchProject(projectPath: string) {
-        throw new Error('Method not implemented.');
-    }
-
-    static async removeProject(projectPath: string): Promise<void> {
-
-        const serviceName = await ProjectUtils.getProjectServiceName(projectPath);
-        await RuntimeUtils.uninstallProject(serviceName);
-    }
-
-    static async uninstallProject(serviceName: string): Promise<void> {
-
-        // Cannot properly uninstall if the runtime is not installed and running
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
-
-        await RuntimeUtils.runtimeFetch(`/${serviceName}/project`, true, {
-            method: 'DELETE'
-        });
-
-        /* Normally the runtime handle that
-        // Erase all files prefixed with the project name in the runtime data folder
-        const runtimeDataDir = path.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, "data");
-        const files = await fs.readdir(runtimeDataDir);
-        for (const file of files) {
-            if (file.startsWith(project)) {
-                await fs.unlink(path.join(runtimeDataDir, file));
-            }
-        }
-        */
-    }
-
-    //#endregion
-
-    //#region Test report helpers
-
-    private static async persistTestReport(sourcePath: string, destPath: string, isPartial: boolean): Promise<void> {
-
-        let newReport: IProcessTestReport;
-        try {
-            const content = await fs.readFile(sourcePath, "utf8");
-            newReport = JSON.parse(content) as IProcessTestReport;
-        } catch {
-            console.warn(chalk.yellow("Could not read test report from runtime output."));
-            return;
-        }
-
-        if (!isPartial) {
-            await fs.writeFile(destPath, JSON.stringify(newReport, null, 2), "utf8");
-            return;
-        }
-
-        // Merge partial results into any existing report
-        let existingReport: IProcessTestReport | null = null;
-        try {
-            const content = await fs.readFile(destPath, "utf8");
-            existingReport = JSON.parse(content) as IProcessTestReport;
-        } catch {
-            // No existing report — use the new one as-is
-        }
-
-        const merged = existingReport
-            ? RuntimeUtils.mergeTestReports(existingReport, newReport)
-            : newReport;
-
-        await fs.writeFile(destPath, JSON.stringify(merged, null, 2), "utf8");
-    }
-
-    private static mergeTestReports(existing: IProcessTestReport, partial: IProcessTestReport): IProcessTestReport {
-
-        const updatedTests = [...existing.Tests];
-
-        for (const newTest of partial.Tests) {
-            const idx = updatedTests.findIndex(t => t.Name === newTest.Name);
-            if (idx >= 0) {
-                updatedTests[idx] = newTest;
-            } else {
-                updatedTests.push(newTest);
-            }
-        }
-
-        const successCount = updatedTests.filter(t => t.Success).length;
-        const failureCount = updatedTests.filter(t => !t.Success).length;
-
-        return {
-            ...existing,
-            ExecutionId: partial.ExecutionId,
-            Tests: updatedTests,
-            SuccessCount: successCount,
-            FailureCount: failureCount,
-            Success: failureCount === 0,
-        };
-    }
-
-    //#endregion
-}