@codenotch/codenotch.cli 1.0.52 → 1.0.54

package/dist/utils/RuntimeUtils.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -13,9 +46,10 @@ const node_child_process_1 = require("node:child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const decompress_1 = __importDefault(require("decompress"));
 const FileUtils_1 = __importDefault(require("./FileUtils"));
-const ProjectUtils_1 = __importDefault(require("./ProjectUtils"));
+const ProjectUtils_1 = __importStar(require("./ProjectUtils"));
 const GitHubAuthUtils_1 = __importDefault(require("./GitHubAuthUtils"));
 const ProjectCompilationUtils_1 = __importDefault(require("./ProjectCompilationUtils"));
+const ConsoleUtils_1 = __importDefault(require("./ConsoleUtils"));
 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
@@ -28,6 +62,8 @@ class RuntimeUtils {
     static DEFAULT_RUNTIME_HOST = "127.0.0.1";
     static DEFAULT_RUNTIME_PORT = 5005;
     static ADMIN_USER_EMAIL = "admin@example.com";
+    /** A deployment the runtime does not conclude within this delay is reported as failed rather than waited for ever */
+    static DEPLOY_TIMEOUT_MS = 5 * 60 * 1000;
     //#region Runtime 
     static async readRuntimeMeta() {
         try {
@@ -97,19 +133,49 @@ class RuntimeUtils {
         //TODO some way to cache and reuse this
         return response.access_token;
     }
+    /**
+     * Makes sure the runtime is installed, proposing to install it when it is not.
+     * Outside a terminal the proposal is accepted, so scripts and CI keep working unattended.
+     * Returns false when the user declined, after a message telling how to install it.
+     */
     static async ensureRuntimeInstalled() {
+        if (await RuntimeUtils.isRuntimeInstalled()) {
+            return true;
+        }
+        if (!await ConsoleUtils_1.default.confirm('Codenotch runtime is not installed. Install it now?', true)) {
+            console.error(chalk_1.default.yellow(`Codenotch runtime is not installed, run 'cn runtime install' to install it.`));
+            return false;
+        }
+        //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();
+        return true;
+    }
+    /**
+     * Makes sure the runtime is running, proposing to install it and/or start it when it is not.
+     * Outside a terminal the proposal is accepted, so scripts and CI keep working unattended.
+     * Returns false when the user declined, after a message telling how to do it by hand.
+     */
+    static async ensureRuntimeIsRunning(options) {
+        if (await RuntimeUtils.isRuntimeRunning()) {
+            return true;
+        }
+        // A missing runtime is one question, not two: install and start go together
         const isInstalled = await RuntimeUtils.isRuntimeInstalled();
+        const question = isInstalled
+            ? 'Codenotch runtime is not running. Start it now?'
+            : 'Codenotch runtime is not installed. Install and start it now?';
+        if (!await ConsoleUtils_1.default.confirm(question, true)) {
+            console.error(chalk_1.default.yellow(isInstalled
+                ? `Codenotch runtime is not running, run 'cn runtime start' to start it.`
+                : `Codenotch runtime is not installed, run 'cn runtime install' to install it.`));
+            return false;
+        }
         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() {
-        const isRunning = await RuntimeUtils.isRuntimeRunning();
-        if (isRunning) {
-            return;
-        }
-        await RuntimeUtils.startRuntime();
+        await RuntimeUtils.startRuntime(options);
+        return true;
     }
     static async isRuntimeInstalled() {
         const targetExe = RuntimeUtils.getRuntimeExecutablePath();
@@ -167,7 +233,7 @@ class RuntimeUtils {
                 child.stdout?.on("data", (chunk) => {
                     const text = chunk.toString();
                     stdout += text;
-                    process.stdout.write(text);
+                    process.stderr.write(text); // the output of the runtime is a log, stdout stays for the results of the CLI
                 });
                 child.stderr?.on("data", (chunk) => {
                     const text = chunk.toString();
@@ -198,11 +264,15 @@ class RuntimeUtils {
         const exeName = platform === "win32" ? "codenotch.exe" : "codenotch";
         return node_path_1.default.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, exeName);
     }
-    static async installLatestRuntime() {
-        let wasRunning = await RuntimeUtils.isRuntimeRunning();
-        if (wasRunning) {
-            await RuntimeUtils.stopRuntime();
-        }
+    /** "v0.1.5", "0.1.5 " and "V0.1.5" name the same release */
+    static normalizeVersion(version) {
+        return version.trim().replace(/^v/i, '');
+    }
+    /**
+     * Installs the latest runtime release, or updates the installed runtime to it when it is newer.
+     * Returns false when the installed runtime already is that release (`force` reinstalls it anyway).
+     */
+    static async installLatestRuntime(options) {
         const platform = process.platform; // win32 | linux | darwin
         const exeName = platform === "win32" ? "codenotch.exe" : "codenotch";
         let assetName;
@@ -219,7 +289,7 @@ class RuntimeUtils {
         const headers = {
             Authorization: `Bearer ${token}`,
         };
-        console.log(chalk_1.default.blue(`Getting latest Codenotch runtime release metadata...`));
+        ConsoleUtils_1.default.log(chalk_1.default.blue(`Getting latest Codenotch runtime release metadata...`));
         const latestReleaseRes = await fetch("https://api.github.com/repos/EchinoHub/service-core/releases/latest", {
             headers: {
                 ...headers,
@@ -237,7 +307,21 @@ class RuntimeUtils {
             throw new Error(`Asset not found: ${assetName}.`);
         }
         const version = release.tag_name;
-        console.log(chalk_1.default.blue(`Downloading Codenotch runtime from ${asset.url}...`));
+        // Downloading the release already installed would only cost time and a restart
+        if (!options?.force && await RuntimeUtils.isRuntimeInstalled()) {
+            const installedVersion = await RuntimeUtils.getRuntimeVersion();
+            if (RuntimeUtils.normalizeVersion(installedVersion) === RuntimeUtils.normalizeVersion(version)) {
+                ConsoleUtils_1.default.log(chalk_1.default.green(`Codenotch runtime is already up to date (${version}).`));
+                return false;
+            }
+            ConsoleUtils_1.default.log(chalk_1.default.blue(`Updating Codenotch runtime ${installedVersion} to ${version}...`));
+        }
+        // The executable cannot be replaced under a running runtime
+        const wasRunning = await RuntimeUtils.isRuntimeRunning();
+        if (wasRunning) {
+            await RuntimeUtils.stopRuntime();
+        }
+        ConsoleUtils_1.default.log(chalk_1.default.blue(`Downloading Codenotch runtime from ${asset.url}...`));
         const res = await fetch(asset.url, {
             redirect: "follow",
             headers: {
@@ -246,7 +330,7 @@ class RuntimeUtils {
             }
         });
         if (!res.ok || !res.body) {
-            console.log(chalk_1.default.red(`Failed to download runtime from ${asset.url}`));
+            console.error(chalk_1.default.red(`Failed to download runtime from ${asset.url}`));
             throw new Error(`Download failed: ${res.status} ${res.statusText}`);
         }
         const tempRoot = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "codenotch-"));
@@ -270,7 +354,7 @@ class RuntimeUtils {
                 version: version,
                 dataPath: existingMeta?.dataPath
             });
-            console.log(chalk_1.default.blue(`The runtime has been installed successfully.`));
+            ConsoleUtils_1.default.log(chalk_1.default.blue(`The runtime has been installed successfully.`));
         }
         finally {
             FileUtils_1.default.deleteRecursively(tempRoot);
@@ -278,19 +362,23 @@ class RuntimeUtils {
         if (wasRunning) {
             await RuntimeUtils.startRuntime();
         }
+        return true;
     }
     static async startRuntime(options) {
         const isRunning = await RuntimeUtils.isRuntimeRunning();
         if (isRunning) {
             return;
         }
-        await this.ensureRuntimeInstalled();
+        // Installing is a decision of the caller (see ensureRuntimeInstalled / ensureRuntimeIsRunning), not a side effect of starting
+        if (!await RuntimeUtils.isRuntimeInstalled()) {
+            throw new Error(`Codenotch runtime is not installed, run 'cn runtime install' to install it.`);
+        }
         // Start the runtime process in detached mode by default
         let detached = true;
         if (options?.attach) {
             detached = false;
         }
-        console.log(chalk_1.default.blue(`Starting Codenotch runtime ${detached ? "in detached mode" : "in attached mode"}...`));
+        ConsoleUtils_1.default.log(chalk_1.default.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();
@@ -309,7 +397,7 @@ class RuntimeUtils {
         while (attempts < maxAttempts) {
             try {
                 await RuntimeUtils.runtimeFetch("/health");
-                console.log(chalk_1.default.green(`Runtime is ready!`));
+                ConsoleUtils_1.default.log(chalk_1.default.green(`Runtime is ready!`));
                 return; // Runtime is responsive
             }
             catch (e) {
@@ -317,7 +405,7 @@ class RuntimeUtils {
                 attempts++;
             }
         }
-        console.log(chalk_1.default.red(`Failed to start runtime: runtime did not become responsive within expected time.`));
+        console.error(chalk_1.default.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() {
@@ -357,10 +445,10 @@ class RuntimeUtils {
         const dataDir = node_path_1.default.join(RuntimeUtils.CODENOTCH_INSTALL_DIR, RuntimeUtils.CODENOTCH_DATA_FOLDER);
         try {
             await promises_1.default.rm(dataDir, { recursive: true, force: true });
-            console.log(chalk_1.default.green(`Runtime data cleared successfully.`));
+            ConsoleUtils_1.default.log(chalk_1.default.green(`Runtime data cleared successfully.`));
         }
         catch (error) {
-            console.log(chalk_1.default.red(`Failed to clear runtime data: ${error}`));
+            console.error(chalk_1.default.red(`Failed to clear runtime data: ${error}`));
             throw error;
         }
     }
@@ -399,33 +487,116 @@ class RuntimeUtils {
     }
     //#endregion
     //#region Project management
+    /**
+     * Build, deploy and start the project on the runtime, proposing to install/start the runtime when needed.
+     * Returns false when the runtime was declined or the deployment failed.
+     */
     static async startProject(projectPath) {
         //TODO multiproject support
         //TODO --watch mode
         const serviceName = await ProjectUtils_1.default.getProjectServiceName(projectPath);
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
+        if (!await RuntimeUtils.ensureRuntimeIsRunning()) {
+            return false;
+        }
         const outputPath = node_path_1.default.join(node_os_1.default.tmpdir(), `cn-build-${Date.now()}.zip`);
         try {
-            console.log(chalk_1.default.blue(`Building project "${serviceName}"...`));
+            ConsoleUtils_1.default.log(chalk_1.default.blue(`Building project "${serviceName}"...`));
             await ProjectUtils_1.default.packageProject(projectPath, outputPath, true);
-            console.log(chalk_1.default.blue(`Deploying project "${serviceName}" to runtime...`));
+            ConsoleUtils_1.default.log(chalk_1.default.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
+            const deployed = await RuntimeUtils.deployProject(serviceName, outputPath);
+            if (deployed.success) {
+                ConsoleUtils_1.default.log(chalk_1.default.green(`Project "${serviceName}" is now running.`));
+            }
+            else {
+                ConsoleUtils_1.default.error(`Project start failed.`);
+            }
+            return deployed.success;
+        }
+        finally {
+            // Remove the build
+            FileUtils_1.default.deleteRecursively(outputPath);
+        }
+    }
+    /**
+     * Redeploy the project on the runtime: the sources are packaged and uploaded, the runtime
+     * restarts the service with them. The runtime is started when it is not running yet, and a
+     * project the runtime does not know yet is deployed as a whole.
+     * Returns false when the deployment failed, the errors being printed by the runtime call.
+     */
+    static async refreshProject(projectPath, options) {
+        const serviceName = await ProjectUtils_1.default.getProjectServiceName(projectPath);
+        const result = { success: false, serviceName, errors: [], warnings: [] };
+        // 'refresh' syncs a running runtime, a stopped one is no reason to give up: propose to start it
+        if (!await RuntimeUtils.isRuntimeRunning()) {
+            if (!await RuntimeUtils.ensureRuntimeIsRunning()) {
+                result.errors.push('Codenotch runtime is not running');
+                return result;
+            }
             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_1.default.green(`Project "${serviceName}" is now running.`));
+        }
+        // What the runtime holds right now, only to tell a first deployment from an update
+        const currentState = await RuntimeUtils.getProjectState(serviceName);
+        result.mode = currentState === undefined ? 'deploy' : 'update';
+        result.previousVersion = currentState?.projectVersion;
+        const outputPath = node_path_1.default.join(node_os_1.default.tmpdir(), `cn-refresh-${Date.now()}.zip`);
+        try {
+            ConsoleUtils_1.default.log(chalk_1.default.blue(`Building project "${serviceName}"...`));
+            try {
+                const compilation = await ProjectUtils_1.default.packageProject(projectPath, outputPath, options?.ignoreErrors ?? false);
+                result.warnings.push(...compilation.warnings);
+            }
+            catch (error) {
+                // The compilation errors are listed by the packaging, only the way out is left to say
+                const message = error instanceof Error ? error.message : String(error);
+                result.errors.push(...(error instanceof ProjectUtils_1.CompilationError ? error.errors : [message]));
+                ConsoleUtils_1.default.error(message);
+                ConsoleUtils_1.default.warn(options?.ignoreErrors
+                    ? `Nothing was deployed, the runtime still serves the version it holds.`
+                    : `Nothing was deployed. Fix the errors above, or run with '--ignore-errors' to deploy anyway.`);
+                return result;
+            }
+            ConsoleUtils_1.default.log(chalk_1.default.blue(currentState === undefined
+                ? `Project "${serviceName}" is not on the runtime yet, deploying it...`
+                : `Deploying the changes of "${serviceName}" (deployed version ${currentState.projectVersion})...`));
+            const deployed = await RuntimeUtils.deployProject(serviceName, outputPath);
+            result.success = deployed.success;
+            result.status = deployed.status;
+            result.errors.push(...deployed.errors);
+            result.warnings.push(...deployed.warnings);
+            if (deployed.success) {
+                ConsoleUtils_1.default.log(chalk_1.default.green(`Project "${serviceName}" is in sync with its sources.`));
             }
             else {
-                console.log(chalk_1.default.red(`Project start failed.`));
+                ConsoleUtils_1.default.error(`Project refresh failed.`);
             }
+            return result;
         }
         finally {
             // Remove the build
             FileUtils_1.default.deleteRecursively(outputPath);
         }
     }
+    /**
+     * The deployment state the runtime holds for a service, undefined when it does not know it
+     * (never deployed, removed since, or the runtime cannot be reached).
+     */
+    static async getProjectState(serviceName) {
+        try {
+            return await RuntimeUtils.runtimeFetch(`/${serviceName}/project`, true);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Runs the tests of the project with a separate instance of the runtime, proposing to install it when needed.
+     * Returns false when the runtime was declined.
+     */
     static async testProject(projectPath, fileFilter, nameFilter, inPlace = false) {
-        await RuntimeUtils.ensureRuntimeInstalled();
+        if (!await RuntimeUtils.ensureRuntimeInstalled()) {
+            return undefined;
+        }
         // 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);
@@ -473,13 +644,12 @@ class RuntimeUtils {
             await compileFunc(projectPath);
             const tempReportPath = node_path_1.default.join(node_os_1.default.tmpdir(), `cn-report-${Date.now()}.json`);
             try {
-                await testFunc(projectPath, tempReportPath);
-                await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
+                const report = await RuntimeUtils.runTestsAndPersist(testFunc, projectPath, tempReportPath, finalReportPath, isPartial);
+                return { report, reportPath: finalReportPath };
             }
             finally {
                 await promises_1.default.unlink(tempReportPath).catch(() => { });
             }
-            return;
         }
         const tempRoot = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "codenotch-"));
         try {
@@ -487,8 +657,8 @@ class RuntimeUtils {
             await FileUtils_1.default.copyFolder(projectPath, tempRoot, ['.git', 'node_modules', 'dist', 'build', 'out']);
             await compileFunc(tempRoot);
             const tempReportPath = node_path_1.default.join(tempRoot, "test-report.json");
-            await testFunc(tempRoot, tempReportPath);
-            await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
+            const report = await RuntimeUtils.runTestsAndPersist(testFunc, tempRoot, tempReportPath, finalReportPath, isPartial);
+            return { report, reportPath: finalReportPath };
         }
         finally {
             // Clean up temp folder
@@ -496,19 +666,38 @@ class RuntimeUtils {
             await FileUtils_1.default.deleteRecursively(tempRoot);
         }
     }
+    /**
+     * Runs the tests and persists their report. A run the runtime ends in error still yields its
+     * report when it wrote one: failing tests are told by the report, not by the exit code.
+     */
+    static async runTestsAndPersist(testFunc, workPath, tempReportPath, finalReportPath, isPartial) {
+        let runError;
+        try {
+            await testFunc(workPath, tempReportPath);
+        }
+        catch (error) {
+            runError = error;
+        }
+        const report = await RuntimeUtils.persistTestReport(tempReportPath, finalReportPath, isPartial);
+        if (report === undefined && runError !== undefined) {
+            throw runError;
+        }
+        return report;
+    }
     static async deployProject(serviceName, packagePath) {
+        const result = { success: false, serviceName, errors: [], warnings: [] };
         // 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 promises_1.default.access(zipFilePath);
         }
         catch (error) {
-            console.log(chalk_1.default.red(`Project package not found: ${zipFilePath}`));
             throw new Error(`Project package not found: ${zipFilePath}`);
         }
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
+        if (!await RuntimeUtils.ensureRuntimeIsRunning()) {
+            result.errors.push('Codenotch runtime is not running');
+            return result;
+        }
         const zipBuffer = await promises_1.default.readFile(zipFilePath);
         const zipBlob = new Blob([zipBuffer], { type: "application/zip" });
         const form = new FormData();
@@ -518,36 +707,49 @@ class RuntimeUtils {
             method: "POST",
             body: form
         });
-        // Wait until the project deployment has completed
-        while (true) {
+        // Wait until the project deployment has completed, a runtime stuck in between is reported rather than waited for ever
+        const deadline = Date.now() + RuntimeUtils.DEPLOY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
             await new Promise(resolve => setTimeout(resolve, 1000));
             try {
                 const projectState = await RuntimeUtils.runtimeFetch(`/${serviceName}/project`, true);
+                result.status = projectState.status;
+                result.warnings = projectState.warnings ?? [];
                 if (projectState.status === "READY") {
-                    console.log(chalk_1.default.green(`${serviceName} is ready!`));
-                    return true;
+                    ConsoleUtils_1.default.log(chalk_1.default.green(`${serviceName} is ready!`));
+                    result.success = true;
+                    return result;
                 }
-                else if (projectState.status === "FAILURE" || projectState.status === "REMOVING") {
-                    console.log(chalk_1.default.red(`Failed to deploy ${serviceName}. Errors: ${projectState.errors?.join(", ")}`));
-                    return false;
+                if (projectState.status === "FAILURE" || projectState.status === "REMOVING") {
+                    result.errors = projectState.errors ?? [];
+                    ConsoleUtils_1.default.error(`Failed to deploy ${serviceName}. Errors: ${result.errors.join(", ")}`);
+                    return result;
                 }
             }
             catch {
                 // Keep waiting
             }
         }
+        result.errors.push(`The runtime did not report '${serviceName}' as ready within ${RuntimeUtils.DEPLOY_TIMEOUT_MS / 1000} seconds (last status: ${result.status ?? 'unknown'}).`);
+        ConsoleUtils_1.default.error(result.errors[result.errors.length - 1]);
+        return result;
     }
-    static async patchProject(projectPath) {
-        throw new Error('Method not implemented.');
-    }
+    /** Uninstalls the project of the given folder from the runtime, false when nothing was removed. */
     static async removeProject(projectPath) {
         const serviceName = await ProjectUtils_1.default.getProjectServiceName(projectPath);
-        await RuntimeUtils.uninstallProject(serviceName);
+        return await RuntimeUtils.uninstallProject(serviceName);
     }
+    /** Uninstalls the project from the runtime, false when nothing was removed. */
     static async uninstallProject(serviceName) {
-        // Cannot properly uninstall if the runtime is not installed and running
-        // Ensure the runtime is running
-        await RuntimeUtils.startRuntime();
+        // Installing a runtime only to delete a project on it makes no sense: without one there is nothing to remove
+        if (!await RuntimeUtils.isRuntimeInstalled()) {
+            console.error(chalk_1.default.yellow(`Codenotch runtime is not installed, there is no project to remove.`));
+            return false;
+        }
+        // The removal is done by the runtime itself, so it has to run
+        if (!await RuntimeUtils.ensureRuntimeIsRunning()) {
+            return false;
+        }
         await RuntimeUtils.runtimeFetch(`/${serviceName}/project`, true, {
             method: 'DELETE'
         });
@@ -561,9 +763,11 @@ class RuntimeUtils {
             }
         }
         */
+        return true;
     }
     //#endregion
     //#region Test report helpers
+    /** Writes the report of a run to `destPath` (merged into the previous one for a partial run) and returns it, undefined when the runtime wrote none */
     static async persistTestReport(sourcePath, destPath, isPartial) {
         let newReport;
         try {
@@ -572,11 +776,11 @@ class RuntimeUtils {
         }
         catch {
             console.warn(chalk_1.default.yellow("Could not read test report from runtime output."));
-            return;
+            return undefined;
         }
         if (!isPartial) {
             await promises_1.default.writeFile(destPath, JSON.stringify(newReport, null, 2), "utf8");
-            return;
+            return newReport;
         }
         // Merge partial results into any existing report
         let existingReport = null;
@@ -591,6 +795,7 @@ class RuntimeUtils {
             ? RuntimeUtils.mergeTestReports(existingReport, newReport)
             : newReport;
         await promises_1.default.writeFile(destPath, JSON.stringify(merged, null, 2), "utf8");
+        return merged;
     }
     static mergeTestReports(existing, partial) {
         const updatedTests = [...existing.Tests];