cob-cli 2.51.0 → 2.52.0-beta-1

package/lib/task_lists/common_enviromentHandler.js

@@ -5,6 +5,7 @@ const git = require('simple-git');
 const fs = require('fs-extra');
 const { getCurrentBranch } = require("./common_releaseManager");
 const { SERVER_COB_CLI_DIRECTORY } = require("./common_helpers")
+const { getSshArgs } = require("./common_helpers")
 
 const SERVER_LAST_ENV_FILE = SERVER_COB_CLI_DIRECTORY + "lastDeployEnv";
 
@@ -66,7 +67,7 @@ exports.getCurrentCommandEnviroment = getCurrentCommandEnviroment;
 
 /* ************************************ */
 async function _applySpecific(environmentName) {
-    const envSpecificFiles = await fg(['**/*.ENV__'+ environmentName +'__.*'], { onlyFiles: false, dot: true });    
+    const envSpecificFiles = await fg(['**/*.ENV__'+ environmentName +'__.*'], { onlyFiles: false, dot: true });
 
     for( let envSpecificFile of envSpecificFiles ) {
         let prodFile   = envSpecificFile.replace(/\.ENV__.*__/,"")
@@ -74,7 +75,7 @@ async function _applySpecific(environmentName) {
         if(!fs.existsSync(deleteFile)) {
             if(fs.existsSync(prodFile)) {
                 let backupFile = envSpecificFile.replace(/\.ENV__.*__/,".ENV__ORIGINAL_BACKUP__")
-                await git().raw(["update-index","--assume-unchanged", prodFile])
+                await git().raw(["update-index","--assume-unchanged", prodFile]).catch(() => {})
                 fs.renameSync(prodFile, backupFile)
             } else {
                 fs.appendFileSync('.git/info/exclude', "\n" + prodFile)
@@ -82,7 +83,7 @@ async function _applySpecific(environmentName) {
             }
         }
         fs.renameSync(envSpecificFile, prodFile)
-        await git().raw(["update-index","--assume-unchanged", envSpecificFile])
+        await git().raw(["update-index","--assume-unchanged", envSpecificFile]).catch(() => {})
     }
 }
 
@@ -94,11 +95,11 @@ async function _undoSpecific(environmentName) {
         let prodFile = changedFile.replace(/\.ENV__.*__/,"")
         let originalEnvSpecificFile = changedFile.replace(/\.ENV__.*__/,'.ENV__' + environmentName + '__')
         fs.renameSync(prodFile, originalEnvSpecificFile)
-        await git().raw(["update-index","--no-assume-unchanged", originalEnvSpecificFile])
-        
+        await git().raw(["update-index","--no-assume-unchanged", originalEnvSpecificFile]).catch(() => {})
+
         if( changedFile.indexOf("\.ENV__ORIGINAL_BACKUP__") > 0 ) {
             fs.renameSync(changedFile, prodFile)
-            await git().raw(["update-index","--no-assume-unchanged", prodFile])
+            await git().raw(["update-index","--no-assume-unchanged", prodFile]).catch(() => {})
         }
         if( changedFile.indexOf("\.ENV__DELETE__")  > 0 ) {
             flagDeleteExclude = true
@@ -120,6 +121,8 @@ function _getDefaultServerForEnvironment(environmentName) {
 
 /* ************************************ */
 function _getServerSSHFQDN(servername) {
+    // return IPs as-is
+    if (servername.includes(".")) return servername;
     return servername + ".cultofbits.pt";
 }
 
@@ -131,16 +134,19 @@ function _getServerHTTPsFQDN(servername) {
 /* ************************************ */
 async function _getLastEnvironmentDeployed(server) {
     try {
-        let result = await execa('ssh', [server, "cat " + SERVER_LAST_ENV_FILE ]);
+        let result = await execa('ssh', [...getSshArgs(server), "cat " + SERVER_LAST_ENV_FILE ]);
         return result.stdout;
     } catch (error) {
+        if (error.exitCode === 255) {
+            throw new Error(`SSH connection to '${server}' failed: ${error.shortMessage}`);
+        }
         return "prod"
     }
 }
 
 /* ************************************ */
 async function _setLastEnvironmentDeployed(server, environmentName) {
-    await execa('ssh', [server, "echo '" + environmentName + "' > " + SERVER_LAST_ENV_FILE ]);
+    await execa('ssh', [...getSshArgs(server), "echo '" + environmentName + "' > " + SERVER_LAST_ENV_FILE ]);
 }
 
 /* ************************************ */

package/lib/task_lists/common_helpers.js

@@ -1,5 +1,43 @@
+const inquirer = require("inquirer")
+const readline = require('readline');
+const yaml = require('js-yaml');
+const fs = require("fs/promises");
+const { getSshArgs } = require("./ssh");
+
 const SERVER_COB_CLI_DIRECTORY = "/opt/cob-cli/";
 
+/* ************************************ */
+function getSshArgs(server) {
+    const args = [
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "PreferredAuthentications=publickey",
+        "-o", "BatchMode=yes",
+    ];
+
+    if (process.env.COB_SSH_PORT)     args.push("-p", process.env.COB_SSH_PORT);
+    if (process.env.COB_SSH_IDENTITY) args.push("-i", process.env.COB_SSH_IDENTITY);
+
+    const target = process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+    args.push(target);
+
+    return args;
+}
+
+/* ************************************ */
+function getServerAddress(server) {
+    return process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+}
+
+/* ************************************ */
+function getRsyncSsh() {
+    let cmd = "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30 -o StrictHostKeyChecking=no";
+
+    if (process.env.COB_SSH_IDENTITY) cmd += ` -i '${process.env.COB_SSH_IDENTITY}'`;
+    if (process.env.COB_SSH_PORT)     cmd += ` -p ${process.env.COB_SSH_PORT}`;
+
+    return cmd;
+}
+
 /* **************************************************************************************** */
 async function checkWorkingCopyCleanliness(testNotDetached=true) {
     const git = require('simple-git');
@@ -32,40 +70,81 @@ async function checkWorkingCopyCleanliness(testNotDetached=true) {
 function checkConnectivity(server) {
     const execa = require('execa');
     return execa('ssh', [
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "PreferredAuthentications=publickey",
-        "-o", "BatchMode=yes",
         "-o", "ConnectTimeout=15",
-        server,
+        ...getSshArgs(server),
         "test -w /etc/recordm/services/com.cultofbits.web.integration.properties && exit || exit 1"
     ])
 }
 
+
 /* ************************************ */
+let readlineSetup = false
 function getKeypress() {
-    const readline = require('readline');
-
+    if (!readlineSetup) {
+        readline.emitKeypressEvents(process.stdin);
+        readlineSetup = true
+    }
     process.stdin.setRawMode(true);
-    readline.emitKeypressEvents(process.stdin);
     const rl = readline.createInterface({
         input: process.stdin
     });
-    return new Promise(resolve => rl.input.on("keypress", (letter,key) => {
-        if(key.name == "return") {
-            console.log("")
-        } else {
-            if(key.ctrl && key.name == 'c') letter = "ctrl+c"
-            rl.close();
-            process.stdin.setRawMode(false);
-            resolve(letter && letter.toLowerCase() || key.name);
+   
+    return new Promise(resolve => {
+        const listener = function(letter,key){
+            if(key.name == "return") {
+                console.log("")
+
+            } else {
+                if(key.ctrl && key.name == 'c') letter = "ctrl+c"
+                rl.input.removeListener('keypress', listener)
+                rl.close();
+                process.stdin.setRawMode(false);
+                resolve(letter && letter.toLowerCase() || key.name);
+            }
         }
-    }))
+        rl.input.on("keypress", listener)
+    })
+}
+
+/* ************************************ */
+async function promptCredentials() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'text',
+            message: 'Enter username:',
+            name: 'username',
+        },
+        {
+            type: 'password',
+            message: 'Enter password:',
+            name: 'password',
+            mask: '*',
+        },
+    ])
+
+    return answers
+};
+
+/* ************************************ */
+async function readYamlFile(filename) {
+    try {
+        const data = await fs.readFile(filename, 'utf-8');
+        const config = yaml.load(data);
+        return config
+    } catch (error) {
+        console.error('Error reading YAML file:', error.message);
+    }
 }
 
 /* ************************************ */
 module.exports = {
     SERVER_COB_CLI_DIRECTORY : SERVER_COB_CLI_DIRECTORY,
+    getSshArgs: getSshArgs,
+    getServerAddress: getServerAddress,
+    getRsyncSsh: getRsyncSsh,
     checkConnectivity: checkConnectivity,
     checkWorkingCopyCleanliness: checkWorkingCopyCleanliness,
-    getKeypress: getKeypress
+    getKeypress: getKeypress,
+    promptCredentials: promptCredentials,
+    readYamlFile: readYamlFile
 };

package/lib/task_lists/common_operationState.js

@@ -0,0 +1,28 @@
+const fs = require('fs-extra');
+const fg = require('fast-glob');
+const STATE_FILE = ".git/cob-cli-state";
+
+function saveOperationState(environment, servername) {
+    try { fs.writeJsonSync(STATE_FILE, { environment, servername }); } catch {}
+}
+
+function loadOperationState() {
+    try { return fs.readJsonSync(STATE_FILE); } catch { return null; }
+}
+
+function clearOperationState() {
+    try { fs.unlinkSync(STATE_FILE); } catch {}
+}
+
+async function checkNoInterruptedRun() {
+    const stateExists = !!loadOperationState();
+    const envBackupFiles = await fg(['**/*.ENV__ORIGINAL_BACKUP__.*', '**/*.ENV__DELETE__.*'], { onlyFiles: false, dot: true });
+    if (stateExists || envBackupFiles.length > 0) {
+        throw new Error(
+            "\nAborted:".red + " found traces of a previous interrupted test/deploy.\n"
+            + "Run " + "cob-cli cleanup".yellow + " to restore the repo to a clean state first.\n"
+        );
+    }
+}
+
+module.exports = { saveOperationState, loadOperationState, clearOperationState, checkNoInterruptedRun };

package/lib/task_lists/common_releaseManager.js

@@ -1,10 +1,9 @@
 const execa = require('execa');
-const fs = require('fs-extra');
 const git = require('simple-git');
 
 const SERVER_CHANGELOG = "/opt/cob-cli/DEPLOYLOG.md";
 const LAST_SHA_FILE = "lastDeploySha"
-const { SERVER_COB_CLI_DIRECTORY } = require("./common_helpers");
+const { SERVER_COB_CLI_DIRECTORY, getSshArgs } = require("./common_helpers");
 const SERVER_LAST_SHA_FILE = SERVER_COB_CLI_DIRECTORY + LAST_SHA_FILE;
 
 /* ************************************ */
@@ -44,18 +43,18 @@ async function registerRelease(cmdEnv) {
     const dateTimeStr = date.toISOString().slice(0,16).replace(/T/," ")
     const deploySignature = cmdEnv.servername + "_" + dateStr
     const newDeployText = `${dateTimeStr} ${user} [${currentSha}/${cmdEnv.currentBranch}]`
-    await execa('ssh', [cmdEnv.server, "echo $'" + newDeployText + "\n" + diffs.replace(/'/g,"\\'") + "' >> " + SERVER_CHANGELOG])
+    await execa('ssh', [...getSshArgs(cmdEnv.server), "echo $'" + newDeployText + "\n" + diffs.replace(/'/g,"\\'") + "' >> " + SERVER_CHANGELOG])
 
     if (diffs) {
         // Add deploy tags to repo
-        git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
+        await git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
         try {
             await git().silent(true).tag([deploySignature, "-d"])
         } catch {}
 
         await git().addAnnotatedTag(deploySignature, newDeployText )
         await git().push(["-f", "origin", deploySignature])
-        git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
+        await git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
     }
     _setLastDeployedSha(cmdEnv.server, currentSha);
 }
@@ -65,9 +64,12 @@ exports.registerRelease = registerRelease;
 async function getLastDeployedSha(server) {
     let result
     try {
-        result = await execa('ssh', [server, "cat " + SERVER_LAST_SHA_FILE ]);
+        result = await execa('ssh', [...getSshArgs(server), "cat " + SERVER_LAST_SHA_FILE ]);
     } catch (error) {
-        await execa('ssh', [server, "mkdir -p " + SERVER_COB_CLI_DIRECTORY ]);
+        if (error.exitCode === 255) {
+            throw new Error(`SSH connection to '${server}' failed: ${error.shortMessage}`);
+        }
+        await execa('ssh', [...getSshArgs(server), "mkdir -p " + SERVER_COB_CLI_DIRECTORY ]);
         return null
     }
     return result.stdout;
@@ -76,7 +78,7 @@ exports.getLastDeployedSha = getLastDeployedSha;
 
 /* ************************************ */
 function _setLastDeployedSha(server, lastSha) {
-    execa('ssh', [server, "echo '" + lastSha + "' > " + SERVER_LAST_SHA_FILE ]);
+    execa('ssh', [...getSshArgs(server), "echo '" + lastSha + "' > " + SERVER_LAST_SHA_FILE ]);
 }
 
 /* ************************************ */

package/lib/task_lists/common_syncFiles.js

@@ -2,6 +2,7 @@ const execa = require('execa');
 const path = require('path');
 const fs = require('fs-extra');
 const { getKeypress } = require("../task_lists/common_helpers");
+const { getRsyncSsh, getServerAddress } = require("./common_helpers");
 
 /* ************************************ */
 const COB_PRODUCTS = ["recordm", "integrationm", "recordm-importer", "reportm", "userm", "confm", "others", "authm"];
@@ -32,6 +33,7 @@ async function _syncFiles(executionType, cmdEnv, from, to, extraOptions = [], ar
         return new Promise(async (resolve, reject) => {
             let fromPath = resolveCobPath(cmdEnv.server, from, product);
             let toPath = resolveCobPath(cmdEnv.server, to, product);
+            if (toPath.startsWith('.') && !fs.existsSync(toPath)) fs.mkdirSync(toPath)
             let productExtraOptions = extraOptions.map( option => option.replace(/=.*\|/,"="))
             productExtraOptions = productExtraOptions.filter( option => option.indexOf("|") < 0 )
 
@@ -64,7 +66,7 @@ async function _syncFiles(executionType, cmdEnv, from, to, extraOptions = [], ar
                 }
                 await execa('rsync', rsyncArgs, {
                     shell: true,
-                    env: { "RSYNC_RSH": "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30" }
+                    env: { "RSYNC_RSH": getRsyncSsh() }
                 })
                     .then((value) => {
                         if (args.verbose > 3)
@@ -169,16 +171,19 @@ function resolveCobPath(server, type, product) {
             return "./" + product + "/";
 
         case "serverInitial":
-            return server + ":/opt/" + product + "/etc.default/";
+            return getServerAddress(server) + ":/opt/" + product + "/etc.default/";
 
         case "serverLive":
             switch (product) {
                 case "recordm-importer":
                 case "others":
-                    return server + ':' + "/opt/" + product + "/";
+                    return getServerAddress(server) + ':' + "/opt/" + product + "/";
                 default:
-                    return server + ':' + "/etc/" + product + "/";
+                    return getServerAddress(server) + ':' + "/etc/" + product + "/";
             }
+
+        case "staging":
+            return ".staging/" + product + "/";
     }
 }
 exports.resolveCobPath = resolveCobPath;

package/lib/task_lists/package_execute.js

@@ -0,0 +1,45 @@
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const verboseRenderer = require('listr-verbose-renderer');
+const { copyFiles } = require("./common_syncFiles");
+const fs = require("fs");
+const tar = require('tar');
+const { format } = require('date-fns');
+
+
+function executeTasks(cmdEnv, args) {
+    console.log("\nPackaging ...");
+
+    return new Listr([
+        {title: "Apply new enviroment specifics", task: () => cmdEnv.applyCurrentCommandEnvironmentChanges() },
+        {title: "Create staging dir",             task: () => fs.existsSync('.staging') || fs.mkdirSync('.staging') },
+        {title: "Copy files to staging dir",      task: () => copyFiles(cmdEnv, "localCopy", "staging")},
+        {title: "Create package",                 task: async () => { const filename = await createPackage(cmdEnv, args); console.log("created " + filename) }},
+        {title: "Sign package",                   task: () => console.log("lololo")},
+        {title: "Delete staging dir",             task: () => fs.rmSync('.staging', {recursive: true, force: true})},
+        {title: "Undo new enviroment specifics",  task: () => cmdEnv.unApplyCurrentCommandEnvironmentChanges() },
+    ], {
+        renderer: args.verbose ? verboseRenderer : UpdaterRenderer,
+        collapse: false
+    });
+}
+exports.executeTasks = executeTasks;
+
+const createPackage = async function(cmdEnv, args){
+   const filename = `${cmdEnv.servername}-${cmdEnv.name}-${format(new Date(), 'yyyy-MM-dd_HH_mm')}.tar.gz`; 
+   const files = fs.readdirSync('.staging')
+   if (args.verbose > 0){
+      console.log("packaging " + files)
+   }
+
+    await tar.create({
+        gzip: true,
+        file: filename,
+        cwd: '.staging',
+        onWriteEntry(entry) {
+            if (args.verbose > 2) console.log('adding', entry.path, entry.stat.mode.toString(8))
+        }
+    }, files)
+
+   return filename;
+}

package/lib/task_lists/ssh.js

@@ -0,0 +1,30 @@
+function getSshArgs(server) {
+    const args = [
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "PreferredAuthentications=publickey",
+        "-o", "BatchMode=yes",
+    ];
+
+    if (process.env.COB_SSH_PORT)     args.push("-p", process.env.COB_SSH_PORT);
+    if (process.env.COB_SSH_IDENTITY) args.push("-i", process.env.COB_SSH_IDENTITY);
+
+    const target = process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+    args.push(target);
+
+    return args;
+}
+
+function getServerAddress(server) {
+    return process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+}
+
+function getRsyncSsh() {
+    let cmd = "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30 -o StrictHostKeyChecking=no";
+
+    if (process.env.COB_SSH_IDENTITY) cmd += ` -i '${process.env.COB_SSH_IDENTITY}'`;
+    if (process.env.COB_SSH_PORT)     cmd += ` -p ${process.env.COB_SSH_PORT}`;
+
+    return cmd;
+}
+
+module.exports = { getSshArgs, getServerAddress, getRsyncSsh };

package/lib/task_lists/tagDefs_execute.js

@@ -0,0 +1,121 @@
+require('colors');
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const VerboseRenderer = require('listr-verbose-renderer');
+const { getFilteredDefinitions } = require('./common_definitions.js')
+const axios = require("axios");
+const inquirer = require("inquirer")
+
+async function getUntaggedChanges(servername, defId) {
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/changes?tagged=false`
+
+    const response = await axios.get(uri, {params: {tagged: false}});
+
+    if(response.status % 200 > 100){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    return ( response.data || []).filter(c => !c.tag)
+}
+
+async function tagDefinition(servername, defId, until) {
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/tag`
+
+    const params = {}
+    if(until) {
+        params.until = until
+    }
+   
+    const response = await axios.put(uri, "", {headers: {'Content-Type': 'application/json'}, params: params});
+
+    if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    return response.data
+}
+
+async function tagDefinitions(servername, customization, defs, args) {
+    return new Listr([
+        {
+            title: `(${customization}) Definitions: `.bold + "searching for definitions matching queries",
+            task: async ctx => ctx.defs = (await getFilteredDefinitions(servername, defs))
+            .map(d => ({id: d.id, name: d.name}))
+        },
+        {
+            title: `(${customization}) Definitions: `.bold + "enriching metadata",
+            task: async ctx => {
+                for (const def of ctx.defs){
+                    def.changes = await getUntaggedChanges(servername, def.id)
+                    if(args.verbose) console.log(`definition ${def.name}: ${def.changes.length} untagged changes`)
+                }
+            }
+        },
+        {
+            title: `(${customization}) Definitions: `.bold + "tagging un-tagged changes",
+            task: async ctx => {
+                const subtasks = ctx.defs.map(d => ({
+                    title: "Tagging changes to " + d.name.bold,
+                    task: async (_, task) => {
+                        if (d.changes.length == 0) {
+                            task.skip("no untagged changes")
+                            return
+                        }
+
+                        if(args.all) {
+                            await tagDefinition(servername, d.id)
+                            task.output = 'Tagged by all'
+                            return
+                        }
+
+                        d.changes.forEach(c => console.log(JSON.stringify(c)))
+
+                        const answer = await inquirer.prompt([
+                            {
+                                type: 'rawlist',
+                                name: 'action',
+                                message: `Do you wish to tag the ${d.changes.length} changes? (^c to abort)`,
+                                choices: [
+                                    'Tag Changes',
+                                    'Choose Changes',
+                                    'Skip',
+                                ]
+                            }
+                        ])
+                        if (answer.action == 'Skip') {
+                            task.skip()
+
+                        } else if (answer.action == 'Tag Changes') {
+                            await tagDefinition(servername, d.id)
+                            task.output = 'Tagged'
+
+                        } else if (answer.action == 'Choose Changes') {
+                           const dates = d.changes.reduce((acc, cur) => {
+                              if(!acc.includes(cur.date)) acc.push(cur.date)
+                              return acc
+                           }, [])
+                           const answerDate = await inquirer.prompt([
+                              {
+                                type: 'rawlist',
+                                name: 'date',
+                                message: `Choose the oldest date to tag`,
+                                choices: dates
+                              }
+                           ])
+                           await tagDefinition(servername, d.id, answerDate.date)
+                           task.output = 'Tagged until ' + answerDate.date
+                        }
+                    }
+                }))
+                return new Listr(subtasks)
+            }
+        },
+    ],{
+        // we need to list changes and read user input, the VerboseRenderer is needed
+        renderer: VerboseRenderer,
+        collapse: false
+    }).run()
+}
+
+
+exports.tagDefinitions = tagDefinitions

package/lib/task_lists/test_customUIsContinuosReload.js

@@ -1,11 +1,28 @@
 const execa = require('execa');
 const path = require('path');
+const net = require('net');
 const concurrently = require('concurrently');
 const fs= require('fs');
 const util  = require('util');
 const child_process = require('child_process');
 const exec = util.promisify(child_process.exec);
 
+function findPort(preferred = 8040) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(preferred, '0.0.0.0', () => {
+            server.close(() => resolve(preferred));
+        });
+        server.on('error', () => {
+            const fallback = net.createServer();
+            fallback.listen(0, '0.0.0.0', () => {
+                const port = fallback.address().port;
+                fallback.close(() => resolve(port));
+            });
+        });
+    });
+}
+
 
 async function customUIsContinuosReload(cmdEnv, dashboard) {
     process.env.dash_dir = dashboard
@@ -22,6 +39,9 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         throw new Error("Aborted: ".red + " dashboard " + dashboard.bold + " does not exist.\n  ")
     }
 
+    const dashPort = await findPort(8041);
+    process.env.dash_port = dashPort;
+
     if(dashboardPathIsDirectory) {
         // If we have a dashboard to serve run it from local dashboard directory on 8081 with vue-cli-service
         // it will use its vue.config.js
@@ -31,13 +51,15 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         commands.push( {
             command: [
                 "cd " + dashboardPath + ";",
-                "node_modules/.bin/vue-cli-service serve --port 8041 2>/dev/null" 
-            ].join(" "), 
+                "node_modules/.bin/vue-cli-service serve --port " + dashPort + " 2>/dev/null"
+            ].join(" "),
             name: 'dashboard server',
-            prefixColor: "red" 
+            prefixColor: "red"
         })
     }
 
+    const port = await findPort(8040);
+
     console.log( "\n" + (" NOTE: Press " + "O".bold.red + " to open default browser, " + "CTRL+C".bold.red + " or " + "Q".bold.red + " to stop the tests... ").yellow.bold + "\n\n" )
 
     const insideCobCliPath = path.resolve(__dirname, '../../node_modules/.bin/webpack-dev-server');
@@ -50,8 +72,9 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
             webpackDevServerPath,
             "--config",
             path.resolve(__dirname, "../webpack/webpack.config.js"),
-            "--mode=development"
-        ].join(" "), 
+            "--mode=development",
+            "--port", port
+        ].join(" "),
         name: 'customUIs server',
         prefixColor: "blue" 
     }) 
@@ -82,14 +105,20 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         }
     }
 
-    conc.result.catch( _err => { 
+    let notifyFailure;
+    const failurePromise = new Promise((_, reject) => { notifyFailure = reject; });
+
+    conc.result.catch( _err => {
         if(isStopping) return;
 
         stopEverything();
+        notifyFailure(new Error('processes-failed'));
     });
 
     return {
-        stop: stopEverything
+        stop: stopEverything,
+        failed: failurePromise,
+        port
     };
 }
 exports.customUIsContinuosReload = customUIsContinuosReload;