eitri-cli 1.0.4 → 1.1.0-beta

package/src/service/Workspace.js

@@ -1,231 +1,279 @@
-const fs = require('fs')
-const path = require('path')
-const Http = require('./Http')
-const Base64 = require('base-64')
-const TagTree = require('./TagTree')
-const FormData = require('form-data')
-const { v4: uuidv4 } = require('uuid')
-const config = require('config')
-const AdmZip = require('adm-zip')
-const BlindGuardian = require('./BlindGuardian')
-const HashFolder = require('./HashFolder')
-const packageJson = require(path.resolve(__dirname, '..', '..', 'package.json'))
-const tempFolderPath = require('../util/os').OS_MAPPER
-const TargetService = require('../service/TargetService')
-const WatcherOpts = require('../enum/WatcherOpts')
-const { default: axios } = require('../../node_modules/axios/index')
-const ipv4 = require('../util/ipv4')
-const { compressToBase64 } = require('lz-string')
-const Buffer = require('buffer')
-const DEFAULT_ENV = 'dev'
-const cliProgress = require('cli-progress')
+const fs = require("fs");
+const path = require("path");
+const Http = require("./Http");
+const Base64 = require("base-64");
+const TagTree = require("./TagTree");
+const FormData = require("form-data");
+const { v4: uuidv4 } = require("uuid");
+const config = require("config");
+const AdmZip = require("adm-zip");
+const BlindGuardian = require("./BlindGuardian");
+const HashFolder = require("./HashFolder");
+const packageJson = require(path.resolve(
+    __dirname,
+    "..",
+    "..",
+    "package.json"
+));
+const tempFolderPath = require("../util/os").OS_MAPPER;
+const TargetService = require("../service/TargetService");
+const WatcherOpts = require("../enum/WatcherOpts");
+const { default: axios } = require("../../node_modules/axios/index");
+const ipv4 = require("../util/ipv4");
+const { compressToBase64 } = require("lz-string");
+const Buffer = require("buffer");
+const DEFAULT_ENV = "dev";
+const cliProgress = require("cli-progress");
+const EitriAppManager = require("./EitriAppManager");
+const getWorkspace = require("../util/getWorkspace");
 class Workspace {
     constructor(blindGuardian, hashFolder) {
-        this.config = config.get('workspace')
-        this.basePath = this.config.basePath
-        this.blindGuardian = blindGuardian
-        this.hashFolder = hashFolder
-        this.folder2watch = ''
-        this.resourceFolders2watch = []
-        this.http = new Http(this.blindGuardian)
-        this.upsertQueue = []
-        this.requestNumber = 0
-        this.publishing = false
+        this.config = config.get("workspace");
+        this.basePath = this.config.basePath;
+        this.blindGuardian = blindGuardian;
+        this.hashFolder = hashFolder;
+        this.folder2watch = "";
+        this.resourceFolders2watch = [];
+        this.http = new Http(this.blindGuardian);
+        this.upsertQueue = [];
+        this.requestNumber = 0;
+        this.publishing = false;
         if (!this.config.colossus) {
-            console.warn('Missing colossus config inside workspace.')
+            console.warn("Missing colossus config inside workspace.");
         }
-        this.shareApi = config.get('shareApi')
-        this.webhooks = []
-        this.targets = []
+        this.shareApi = config.get("shareApi");
+        this.webhooks = [];
+        this.targets = [];
 
         /**
          * @type {cliProgress.SingleBar}
          * @private
          */
-        this.progressBar
-        this.progressBarCounter = 0
+        this.progressBar;
+        this.progressBarCounter = 0;
     }
 
     getTargets() {
-        return this.targets
+        return this.targets;
     }
 
     setTargets(targets) {
-        this.targets = targets
+        this.targets = targets;
     }
 
-    getWebhooks () {
-        return this.webhooks
+    getWebhooks() {
+        return this.webhooks;
     }
 
     setWebhooks(webhooks) {
-        this.webhooks = webhooks
+        this.webhooks = webhooks;
     }
 
     setServerUrl(url) {
-        this.serverUrl = url
+        this.serverUrl = url;
     }
 
     setQrCodeUrl(qrCodeUrl) {
-        this.qrCodeUrl = qrCodeUrl
+        this.qrCodeUrl = qrCodeUrl;
     }
 
     setFolder2Watch(folderPath) {
-        this.folder2watch = folderPath
+        this.folder2watch = folderPath;
     }
 
     setResourceFolder2Watch(resourceFolders2watch) {
-        this.resourceFolders2watch = resourceFolders2watch
+        this.resourceFolders2watch = resourceFolders2watch;
     }
 
     getResourceFolder2Watch() {
-        return this.resourceFolders2watch
+        return this.resourceFolders2watch;
     }
 
     async getTargetConfig(id, target) {
-        try{
-            const configs = await this.getAllTargetConfigs(target)
-            const config = configs.find(cfg => cfg.id === id)
-        
-            if(!config) {
-                console.log(`TargetConfig [${target}] não encontrado, utilize o comando --list-target-configs para ver as configurações disponíveis`)
-                process.exit(1)
+        try {
+            const configs = await this.getAllTargetConfigs(target);
+            const config = configs.find((cfg) => cfg.id === id);
+
+            if (!config) {
+                console.log(
+                    `TargetConfig [${target}] não encontrado, utilize o comando --list-target-configs para ver as configurações disponíveis`
+                );
+                process.exit(1);
             }
-        
-            return [config]
+
+            return [config];
         } catch (e) {
-            console.log(`Erro ao buscar configuração: ${e}`)
-            process.exit(1)
+            console.log(`Erro ao buscar configuração: ${e}`);
+            process.exit(1);
         }
     }
 
-    async getAllTargetConfigs(target) {
-        const targetUrl = `${this.config.url}${this.config.targetPath}?name=${target}`
-        try{
-            const response = await axios.get(targetUrl)
-            const fullTarget = response.data
-            const configs = fullTarget[0].targetConfig
-        
-            return configs
+    async getAllTargetConfigs(applicationName) {
+        // const targetUrl = `${this.config.url}${this.config.targetPath}?name=${target}`
+        try {
+            // const response = await axios.get(targetUrl)
+            // const fullTarget = response.data
+
+            const targets = await this.availableTargets();
+            const fullTarget = targets.filter(
+                (a) => a.name === applicationName
+            );
+            const configs = fullTarget[0].targetConfig;
+
+            return configs;
         } catch (e) {
-            console.log(`Erro ao buscar configuração: ${e}`)
-            process.exit(1)
+            console.log(`Erro ao buscar configuração: ${e}`);
+            process.exit(1);
         }
     }
 
     getTarget() {
-
-        if(!this.target) {
-            console.warn('Target não foi detectado no setup()')
+        if (!this.target) {
+            console.warn("Target não foi detectado no setup()");
         }
 
-        return this.target
+        return this.target;
     }
 
     async init() {
-        const token = await this.blindGuardian.getToken()
-        this.http.setToken(token)
-        this.userEmail = token.email
+        const token = await this.blindGuardian.getToken();
+        this.http.setToken(token);
+        this.userEmail = token.email;
     }
 
     getMiniConf() {
         if (!this._miniConf) {
-            const miniAppConfPath = path.resolve(this.folder2watch, '../miniapp.conf.js')
+            const miniAppConfPath = path.resolve(
+                this.folder2watch,
+                "../miniapp.conf.js"
+            );
             if (!fs.existsSync(miniAppConfPath)) {
-                throw new Error('Por favor, verifique se você está dentro da pasta de um projeto eitri-app.')
+                throw new Error(
+                    "Por favor, verifique se você está dentro da pasta de um projeto eitri-app."
+                );
             }
-            this._miniConf = require(miniAppConfPath)
+            this._miniConf = require(miniAppConfPath);
             if (!this._miniConf.version) {
-                throw Error('Arquivo miniapp.conf.js sem version')
+                throw Error("Arquivo miniapp.conf.js sem version");
             }
         }
-        return this._miniConf
+        return this._miniConf;
     }
 
     setMiniConf(miniConf) {
-        this._miniConf = miniConf
+        this._miniConf = miniConf;
         return new Promise((resolve, reject) => {
-            const miniAppConfPath = path.resolve(this.folder2watch, '../miniapp.conf.js')
-            const jsonContent = JSON.stringify(miniConf, null, 4)
-            fs.writeFile(miniAppConfPath, `module.exports = ${jsonContent}`, (err) => {
-                if (err) {
-                    console.log(err)
-                    return reject(err)
+            const miniAppConfPath = path.resolve(
+                this.folder2watch,
+                "../miniapp.conf.js"
+            );
+            const jsonContent = JSON.stringify(miniConf, null, 4);
+            fs.writeFile(
+                miniAppConfPath,
+                `module.exports = ${jsonContent}`,
+                (err) => {
+                    if (err) {
+                        console.log(err);
+                        return reject(err);
+                    }
+                    resolve();
                 }
-                resolve()
-            })
-        })
+            );
+        });
     }
 
     async setup() {
-        const miniConf = this.getMiniConf()
+        const miniConf = this.getMiniConf();
         const headers = {
-            'accept': this.config.libs.updateLibsEndpointVersion
-        }
-        const setupResponse = await this.http.post(`${this.serverUrl}/${this.basePath}/setup`, miniConf, headers) // somente para garantir que a pasta do usuario existe
+            accept: this.config.libs.updateLibsEndpointVersion,
+        };
+        const setupResponse = await this.http.post(
+            `${this.serverUrl}/${this.basePath}/setup`,
+            miniConf,
+            headers
+        ); // somente para garantir que a pasta do usuario existe
 
-        console.log('Preparando compilador')
-        await this.http.put(`${this.serverUrl}/${this.basePath}/version`, miniConf, headers)// TODO PDV Setup fara isso aqui
-        console.log('Compilador pronto para uso contínuo')
+        console.log("Preparando compilador");
+        await this.http.put(
+            `${this.serverUrl}/${this.basePath}/version`,
+            miniConf,
+            headers
+        ); // TODO PDV Setup fara isso aqui
+        console.log("Compilador pronto para uso contínuo");
 
-        const setupData = setupResponse.data
-        
-        const { state, target: remoteTarget } = setupData
+        const setupData = setupResponse.data;
 
-        this.printLibsVersion(state)
+        const { state, target: remoteTarget } = setupData;
 
-        await this.loadTarget(remoteTarget)
+        this.printLibsVersion(state);
 
-        return setupData
+        await this.loadTarget(remoteTarget);
+
+        return setupData;
     }
 
     async loadTarget(remoteTarget) {
-        const targets = await this.availableTargets()
-        this.target = targets.find(t => t.name === remoteTarget.name)
+        const targets = await this.availableTargets();
+        this.target = targets.find((t) => t.name === remoteTarget.name);
 
-        if(!this.target) {
-            throw new Error('Workspace.loadTarget.internalError#missingTarget')
+        if (!this.target) {
+            throw new Error("Workspace.loadTarget.internalError#missingTarget");
         }
     }
 
     printLibsVersion(state) {
-        const miniConf = this.getMiniConf()
-        let libVersionsOutput = ''
-        state.libs.forEach(lib => {
-            let version = miniConf[lib.name]
+        const miniConf = this.getMiniConf();
+        let libVersionsOutput = "";
+        state.libs.forEach((lib) => {
+            let version = miniConf[lib.name];
             if (version) {
                 // Captura a versao da lib quando estamos usando uma url
                 // "https://eitri.s3.amazonaws.com/eitri-app-client-0.8.0-alpha.tgz".match(/(\d+\.\d+\.\d+([-a-z]*))/)
-                const m = version.match(/(\d+\.\d+\.\d+([-a-z]*))/)
+                const m = version.match(/(\d+\.\d+\.\d+([-a-z]*))/);
                 if (m) {
-                    version = m[1]
+                    version = m[1];
                 }
-                libVersionsOutput += `      ${lib.name} [${version}]\n`
+                libVersionsOutput += `      ${lib.name} [${version}]\n`;
             }
-        })
-        console.log(libVersionsOutput)
+        });
+        console.log(libVersionsOutput);
     }
 
     async checkVersions() {
         try {
-            const miniConf = this.getMiniConf()
+            const miniConf = this.getMiniConf();
             const headers = {
-                'accept': this.config.libs.updateLibsEndpointVersion
-            }
-            
+                accept: this.config.libs.updateLibsEndpointVersion,
+            };
+
             // somente para garantir que a pasta do usuario existe
-            await this.http.post(`${this.serverUrl}/${this.basePath}/setup`, miniConf, headers) 
-            console.log('Preparando ambiente de desenvolvimento')
-            const response = await this.http.put(`${this.serverUrl}/${this.basePath}/version?command=push-version`, miniConf, headers)
-            miniConf.target = response.target
-            const availableTargets = await this.availableTargets()
-            let libs = TargetService.getLibsFromMiniConf(miniConf, availableTargets)
-            console.log('Ambiente pronto para compilação')
-            console.log(`${libs.components} [${miniConf[libs.components]}]\n${libs.superApp} [${miniConf[libs.superApp]}]`)
-            return {target: response.target}
+            await this.http.post(
+                `${this.serverUrl}/${this.basePath}/setup`,
+                miniConf,
+                headers
+            );
+            console.log("Preparando ambiente de desenvolvimento");
+            const response = await this.http.put(
+                `${this.serverUrl}/${this.basePath}/version?command=push-version`,
+                miniConf,
+                headers
+            );
+            miniConf.target = response.target;
+            const availableTargets = await this.availableTargets();
+            let libs = TargetService.getLibsFromMiniConf(
+                miniConf,
+                availableTargets
+            );
+            console.log("Ambiente pronto para compilação");
+            console.log(
+                `${libs.components} [${miniConf[libs.components]}]\n${
+                    libs.superApp
+                } [${miniConf[libs.superApp]}]`
+            );
+            return { target: response.target };
         } catch (error) {
             console.log(`\x1b[1m\x1b[31m${error.message}\x1b[0m`);
-            process.exit(1)
+            process.exit(1);
         }
     }
 
@@ -233,15 +281,15 @@ class Workspace {
         return (
             miniConf[packageName] &&
             onlineVersion[packageName] !== miniConf[packageName]
-        )
+        );
     }
 
     async getWorkspaceConnectionData(args, serverUrl) {
-        const cookie = await this.http.getCookieSession(serverUrl)
-        const miniConf = this.getMiniConf()
-        const viewHtml = (args.view || 'index')
-        let environment = process.env.NODE_ENV || DEFAULT_ENV
-        if (environment === 'prod') environment = 'prd'
+        const cookie = await this.http.getCookieSession(serverUrl);
+        const miniConf = this.getMiniConf();
+        const viewHtml = args.view || "index";
+        let environment = process.env.NODE_ENV || DEFAULT_ENV;
+        if (environment === "prod") environment = "prd";
         let miniAppData = {
             developerEmail: this.userEmail,
             environment: environment,
@@ -249,114 +297,126 @@ class Workspace {
             orderId: args.orderId,
             shareId: args.shareId,
             slug: miniConf.slug,
-            publicKey: miniConf['public-key'] || miniConf.publicKey,
-            view: viewHtml
-        }
+            publicKey: miniConf["public-key"] || miniConf.publicKey,
+            view: viewHtml,
+        };
         // delete miniAppData.albCookie
-        return Base64.encode(JSON.stringify(miniAppData))
+        return Base64.encode(JSON.stringify(miniAppData));
     }
 
     async getWorkspaceURL(args, targetConfig) {
-        args = args || {}
-        const cookie = await this.http.getCookieSession(this.serverUrl)
-        let paramOrderId = ''
-        let paramShareId = ''
-        let cid
-        const viewHtml = (args.view || 'index') + '.html'
-        const miniAppConf = this.getMiniConf()
+        args = args || {};
+        const cookie = await this.http.getCookieSession(this.serverUrl);
+        let paramOrderId = "";
+        let paramShareId = "";
+        let cid;
+        const viewHtml = (args.view || "index") + ".html";
+        const miniAppConf = this.getMiniConf();
         const data = {
-            publicKey: miniAppConf['public-key'],
-            metadata: miniAppConf['metadata'],
-            slug: miniAppConf['slug'],
-            title: miniAppConf['title']
-        }
+            publicKey: miniAppConf["public-key"],
+            metadata: miniAppConf["metadata"],
+            slug: miniAppConf["slug"],
+            title: miniAppConf["title"],
+        };
         if (args.orderId) {
-            paramOrderId = '&orderId=' + encodeURIComponent(args.orderId)
+            paramOrderId = "&orderId=" + encodeURIComponent(args.orderId);
         }
         if (args.shareId) {
-            paramShareId = '&shareId=' + encodeURIComponent(args.shareId)
+            paramShareId = "&shareId=" + encodeURIComponent(args.shareId);
         }
         if (args.initializationParams) {
-            data.initializationParams = args.initializationParams
+            data.initializationParams = args.initializationParams;
         }
-        const encodedData = Base64.encode(JSON.stringify(data))
+        const encodedData = Base64.encode(JSON.stringify(data));
         if (cookie) {
-            cid = Base64.encode(cookie.cookieString())
+            cid = Base64.encode(cookie.cookieString());
         }
 
-        if(!targetConfig.bootstrapBaseUrl) {
-            throw new Error('Workspace.getWorkspaceURL.internalError#missingBootstrapBaseUrl')
+        if (!targetConfig.bootstrapBaseUrl) {
+            throw new Error(
+                "Workspace.getWorkspaceURL.internalError#missingBootstrapBaseUrl"
+            );
         }
 
-        let miniAppUrl = `${this.getBootstrapURL(targetConfig.bootstrapBaseUrl)}/${this.config.basePath || 'workspace'}/user/${this.userEmail.replace(
-            '@',
-            '/',
-        )}/${viewHtml}?data=${encodedData}${paramOrderId}${paramShareId}&devmode=true`
+        let miniAppUrl = `${this.getBootstrapURL(
+            targetConfig.bootstrapBaseUrl
+        )}/${
+            this.config.basePath || "workspace"
+        }/user/${(await getWorkspace()).id}/${viewHtml}?data=${encodedData}${paramOrderId}${paramShareId}&devmode=true`;
 
         if (cid) {
-            miniAppUrl = miniAppUrl + '&cid=' + cid
+            miniAppUrl = miniAppUrl + "&cid=" + cid;
         }
-        return miniAppUrl
+        return miniAppUrl;
     }
 
     /**
-     * 
-     * @param {string} bootstrapBaseUrl 
+     *
+     * @param {string} bootstrapBaseUrl
      */
     getBootstrapURL(bootstrapBaseUrl) {
-        const LOCALHOST = 'http://localhost:'
-        if (bootstrapBaseUrl.startsWith(LOCALHOST) && process.env.NODE_ENV === 'loc') {
-            const HOST = ipv4()[0]
-            const PORT = bootstrapBaseUrl.split(LOCALHOST)[1]
-            return `http://${HOST}:${PORT}`
+        const LOCALHOST = "http://localhost:";
+        if (
+            bootstrapBaseUrl.startsWith(LOCALHOST) &&
+            process.env.NODE_ENV === "loc"
+        ) {
+            const HOST = ipv4()[0];
+            const PORT = bootstrapBaseUrl.split(LOCALHOST)[1];
+            return `http://${HOST}:${PORT}`;
         }
-        return bootstrapBaseUrl
+        return bootstrapBaseUrl;
     }
 
     async getNewWorkspaceURL(args, targetConfig) {
-        const qrCodeConfig = await this.getQrCodeConfig(args, targetConfig)
-        const stateData = await this.saveShareState(qrCodeConfig)
-        const stateId = stateData.id
-        const miniAppUrl = `${this.qrCodeUrl}/${stateId}?environment=${(process.env.NODE_ENV === 'hmlv2' ? 'hml' : process.env.NODE_ENV) || 'hml'}`
+        const qrCodeConfig = await this.getQrCodeConfig(args, targetConfig);
+        const stateData = await this.saveShareState(qrCodeConfig);
+        const stateId = stateData.id;
+        const miniAppUrl = `${this.qrCodeUrl}/${stateId}?environment=${
+            (process.env.NODE_ENV === "hmlv2" ? "hml" : process.env.NODE_ENV) ||
+            "hml"
+        }`;
         return {
             miniAppConf: {
                 ...qrCodeConfig,
-                shareId: stateId
+                shareId: stateId,
             },
-            miniAppUrl
-        }
+            miniAppUrl,
+        };
     }
 
     async saveShareState(qrCodeConfig) {
-        const createWorkspaceStateUrl = `${this.serverUrl}/${this.basePath}/share`
+        const createWorkspaceStateUrl = `${this.serverUrl}/${this.basePath}/share`;
         const requestBody = {
             id: uuidv4(),
-            state: qrCodeConfig
-        }
-        const response = await this.http.post(createWorkspaceStateUrl, requestBody)
-        return response.data
+            state: qrCodeConfig,
+        };
+        const response = await this.http.post(
+            createWorkspaceStateUrl,
+            requestBody
+        );
+        return response.data;
     }
 
     async getQrCodeConfig(args, targetConfig) {
-        args = args || {}
-        const cookie = await this.http.getCookieSession(this.serverUrl)
-        let cid
-        const miniAppConf = this.getMiniConf()
-        const view = (args.view || 'index') + '.html'
-        const initializationParams = args.initializationParams
-        const orderId = args.orderId
+        args = args || {};
+        const cookie = await this.http.getCookieSession(this.serverUrl);
+        let cid;
+        const miniAppConf = this.getMiniConf();
+        const view = (args.view || "index") + ".html";
+        const initializationParams = args.initializationParams;
+        const orderId = args.orderId;
 
         if (cookie) {
-            cid = Base64.encode(cookie.cookieString())
+            cid = Base64.encode(cookie.cookieString());
         }
 
         const config = {
             developerEmail: this.userEmail,
-            publicKey: miniAppConf['public-key'],
-            metadata: miniAppConf['metadata'],
-            slug: miniAppConf['slug'],
-            title: miniAppConf['title'],
-            permissions: miniAppConf['permissions'],
+            publicKey: miniAppConf["public-key"],
+            metadata: miniAppConf["metadata"],
+            slug: miniAppConf["slug"],
+            title: miniAppConf["title"],
+            permissions: miniAppConf["permissions"],
 
             // Se nao enviarmos essa url pronta, o superapp tera que monta-la
             // Essa url chama a funcao users.js do workspace-api
@@ -365,239 +425,273 @@ class Workspace {
             orderId,
             view,
             extras: {
-                cid // superapp joga tudo do extras na query string do bootstrapUrl .... Pq ja nao mandamos na queryString ja daqui?
-            }
-        }
+                cid, // superapp joga tudo do extras na query string do bootstrapUrl .... Pq ja nao mandamos na queryString ja daqui?
+            },
+        };
 
-        return config
+        return config;
     }
 
     getRelativePath(filePath) {
         return filePath
-            .replace(this.folder2watch, '')
-            .replace(this.folder2watch.replace(/\\/g, '/'), '')
-            .replace(process.cwd(), '')
+            .replace(this.folder2watch, "")
+            .replace(this.folder2watch.replace(/\\/g, "/"), "")
+            .replace(process.cwd(), "");
     }
 
     async delete(filePath) {
-        const relPath = this.getRelativePath(filePath)
-        const url = `${this.serverUrl}/${this.basePath}/fileupload`
+        const relPath = this.getRelativePath(filePath);
+        const url = `${this.serverUrl}/${this.basePath}/fileupload`;
         const params = {
             filepath: relPath,
-        }
-        await this.http.delete(url, { params })
+        };
+        await this.http.delete(url, { params });
     }
 
     hasAccent(fileName) {
-        const fileRegex = /[À-ź]/g
-        const isValidFileName = !fileRegex.test(fileName)
-        return !isValidFileName
+        const fileRegex = /[À-ź]/g;
+        const isValidFileName = !fileRegex.test(fileName);
+        return !isValidFileName;
     }
 
-
     async upsert(filesPath, opts = {}, showProgressBar = false) {
-        if(showProgressBar) {
-            return await this.upsertConcurrency(filesPath, opts, showProgressBar)
+        if (showProgressBar) {
+            return await this.upsertConcurrency(
+                filesPath,
+                opts,
+                showProgressBar
+            );
         }
-        return await this.upsertSequencial(filesPath, opts)
+        return await this.upsertSequencial(filesPath, opts);
     }
 
     async upsertSequencial(filePath, opts = {}) {
-        const fileName = path.basename(filePath)
+        const fileName = path.basename(filePath);
 
-        const {isInvalid, promise} = await this.validateFileName(fileName, filePath)
-        if(isInvalid) return await promise
+        const { isInvalid, promise } = await this.validateFileName(
+            fileName,
+            filePath
+        );
+        if (isInvalid) return await promise;
 
-        const holder = this.createPromiseHolder()
+        const holder = this.createPromiseHolder();
         this.upsertQueue.push({
             filePath,
             opts,
             holder,
             requestNumber: this.requestNumber++,
-        })
+        });
 
-        const isSaving = opts.why === WatcherOpts.SAVE
+        const isSaving = opts.why === WatcherOpts.SAVE;
 
         if (!this.uploading) {
-            await this.execUpsertSequencial(isSaving)
+            await this.execUpsertSequencial(isSaving);
         }
 
-        return holder.promise
+        return holder.promise;
     }
 
     async upsertConcurrency(filesPath, opts = {}, showProgressBar = false) {
-        const promises = []
-        const isSaving = opts.why === WatcherOpts.SAVE
-        if(showProgressBar) {
-            this.createProgressBar(showProgressBar)
-            this.progressBar.start(filesPath.length, 0)
-            this.progressBar.update(this.progressBarCounter)
+        const promises = [];
+        const isSaving = opts.why === WatcherOpts.SAVE;
+        if (showProgressBar) {
+            this.createProgressBar(showProgressBar);
+            this.progressBar.start(filesPath.length, 0);
+            this.progressBar.update(this.progressBarCounter);
         }
-            
-        for(const filePath of filesPath) {
-            const fileName = path.basename(filePath)
-            
-            const {isInvalid, promise} = await this.validateFileName(fileName, filePath)
-            if(isInvalid) return await promise
+
+        for (const filePath of filesPath) {
+            const fileName = path.basename(filePath);
+
+            const { isInvalid, promise } = await this.validateFileName(
+                fileName,
+                filePath
+            );
+            if (isInvalid) return await promise;
 
             const upsertFile = {
                 filePath,
                 opts,
                 requestNumber: this.requestNumber++,
-            }
-            promises.push(this.execUpsertConcurrency(upsertFile, isSaving, showProgressBar))   
+            };
+            promises.push(
+                this.execUpsertConcurrency(
+                    upsertFile,
+                    isSaving,
+                    showProgressBar
+                )
+            );
         }
-    
-        const promisesChunks = this.spliceArray(promises, 5)
-        const data = []
+
+        const promisesChunks = this.spliceArray(promises, 5);
+        const data = [];
         for (const promiseArray of promisesChunks) {
-            const result = await Promise.all(promiseArray)
-            data.push(...result)
+            const result = await Promise.all(promiseArray);
+            data.push(...result);
         }
 
-        if(isSaving) return data[0]
+        if (isSaving) return data[0];
 
-        if(showProgressBar) {
-            this.progressBar.update(filesPath.length)
-            this.progressBar.stop()
+        if (showProgressBar) {
+            this.progressBar.update(filesPath.length);
+            this.progressBar.stop();
         }
-        return data
+        return data;
     }
 
     async postFile(filePath, isSaving, opts) {
-        const start = new Date().getTime()
-        const relativePath = this.getRelativePath(filePath)
-        const fileName = path.basename(filePath)
+        const start = new Date().getTime();
+        const relativePath = this.getRelativePath(filePath);
+        const fileName = path.basename(filePath);
         if (relativePath.startsWith(this.config.colossus.watchUserDir)) {
-            const allFiles = await this.listFilesInCorrectOrder()
-            const commomModulesPaths = allFiles.filter(f => f.includes('src/commons'))  
-            await this.postLambda(filePath, relativePath, isSaving, commomModulesPaths)
+            const allFiles = await this.listFilesInCorrectOrder();
+            const commomModulesPaths = allFiles.filter((f) =>
+                f.includes("src/commons")
+            );
+            await this.postLambda(
+                filePath,
+                relativePath,
+                isSaving,
+                commomModulesPaths
+            );
         } else {
-            await this.postFormData(filePath, relativePath, opts)
+            await this.postFormData(filePath, relativePath, opts);
         }
         return {
             start,
             relativePath,
-            fileName
-        }
+            fileName,
+        };
     }
 
     async execUpsertConcurrency(upsertFile, isSaving, showProgressBar = false) {
-        const { filePath, opts, requestNumber } = upsertFile
-        
-        const {fileName, relativePath, start} = await this.postFile(filePath, isSaving, opts)
-        
-        if(showProgressBar) {
-            this.progressBarCounter++
-            this.progressBar.update(this.progressBarCounter)
+        const { filePath, opts, requestNumber } = upsertFile;
+
+        const { fileName, relativePath, start } = await this.postFile(
+            filePath,
+            isSaving,
+            opts
+        );
+
+        if (showProgressBar) {
+            this.progressBarCounter++;
+            this.progressBar.update(this.progressBarCounter);
         }
         return {
             filePath,
             relativePath,
             requestNumber,
             time: new Date().getTime() - start,
-            baseName: fileName
-        }
-        
+            baseName: fileName,
+        };
     }
 
     async execUpsertSequencial(isSaving) {
-        this.uploading = true
+        this.uploading = true;
         for (let i = 0; i < this.upsertQueue.length; i++) {
-            const { filePath, opts, holder, requestNumber } = this.upsertQueue[i]
+            const { filePath, opts, holder, requestNumber } =
+                this.upsertQueue[i];
 
             try {
-                const {relativePath, start} = await this.postFile(filePath, isSaving, opts)
+                const { relativePath, start } = await this.postFile(
+                    filePath,
+                    isSaving,
+                    opts
+                );
 
                 holder.resolve({
                     filePath,
                     relativePath,
                     requestNumber,
                     time: new Date().getTime() - start,
-                })
+                });
             } catch (e) {
-                holder.reject(e)
-                break // na duvida se deve abortar a fila toda
+                holder.reject(e);
+                break; // na duvida se deve abortar a fila toda
             }
         }
-        this.upsertQueue = []
-        this.uploading = false
+        this.upsertQueue = [];
+        this.uploading = false;
     }
 
     async validateFileName(fileName, filePath) {
-        const hasAccent = this.hasAccent(fileName)
-        let promise
+        const hasAccent = this.hasAccent(fileName);
+        let promise;
         if (hasAccent) {
-            const message = ` - No nome do arquivo possui um ou mais caracteres não permitidos: ${fileName}`
-            console.log(message)
+            const message = ` - No nome do arquivo possui um ou mais caracteres não permitidos: ${fileName}`;
+            console.log(message);
 
             promise = Promise.resolve({
                 filePath,
                 relativePath: this.getRelativePath(filePath),
                 time: 0,
                 requestNumber: this.requestNumber++,
-                message
-            })
+                message,
+            });
         }
         return {
             isInvalid: hasAccent,
-            promise
-        }
+            promise,
+        };
     }
 
     createPromiseHolder() {
-        const holder = {}
+        const holder = {};
         holder.promise = new Promise((resolve, reject) => {
-            holder.resolve = resolve
-            holder.reject = reject
-        })
-        return holder
+            holder.resolve = resolve;
+            holder.reject = reject;
+        });
+        return holder;
     }
 
     async postFormData(filePath, relativePath, opts) {
-        let conf = this.getMiniConf()
-        const formData = new FormData()
-        formData.append('filepath', relativePath)
-        formData.append('why', opts.why || '')
-        formData.append('file', fs.createReadStream(filePath))
-        formData.append('miniAppVersion', conf.version)
+        let conf = this.getMiniConf();
+        const formData = new FormData();
+        formData.append("filepath", relativePath);
+        formData.append("why", opts.why || "");
+        formData.append("file", fs.createReadStream(filePath));
+        formData.append("miniAppVersion", conf.version);
         if (opts.forceTranspile) {
-            formData.append('forceTranspile', opts.forceTranspile)
+            formData.append("forceTranspile", opts.forceTranspile);
         }
-        const url = `${this.serverUrl}/${this.basePath}/fileupload`
-        return await this.http.postForm(url, formData)
+        const url = `${this.serverUrl}/${this.basePath}/fileupload`;
+        return await this.http.postForm(url, formData);
     }
 
     getEnvCode() {
         if (!this.publishing) {
-            return 'ws'
+            return "ws";
         }
-        if ([ 'dev', 'loc' ].includes(process.env.NODE_ENV)) {
-            return 'dev'
+        if (["dev", "loc"].includes(process.env.NODE_ENV)) {
+            return "dev";
         } else {
-            return 'hml'
+            return "hml";
         }
     }
 
-    async postLambda(filePath, relativePath, isSaving, commomModulesPaths = []) {
+    async postLambda(
+        filePath,
+        relativePath,
+        isSaving,
+        commomModulesPaths = []
+    ) {
+        let commomModules = commomModulesPaths.map((commomFilePath) => {
+            let code = fs.readFileSync(commomFilePath, "utf8");
 
-        let commomModules = commomModulesPaths.map(commomFilePath => {
-            let code = fs.readFileSync(commomFilePath, 'utf8')
+            let name = path.basename(commomFilePath);
 
-            let name = path.basename(commomFilePath)
+            let compressionResult = this.compressCode(code);
 
-            let compressionResult = this.compressCode(code)
+            return { name, ...compressionResult };
+        });
 
-            return { name, ...compressionResult }
-        })
+        let code = fs.readFileSync(filePath, "utf8");
 
-        let code = fs.readFileSync(filePath, 'utf8')
+        let compressionResult = this.compressCode(code);
 
-        let compressionResult = this.compressCode(code)
-
-        let conf = this.getMiniConf()
-        const envCode = this.getEnvCode()
-        const fileName = path.basename(relativePath)
+        let conf = this.getMiniConf();
+        const envCode = this.getEnvCode();
+        const fileName = path.basename(relativePath);
         let data = {
             slug: conf.slug,
             envCode: envCode,
@@ -607,463 +701,546 @@ class Workspace {
             compressionType: compressionResult.compressionType,
             publishing: this.publishing,
             isSaving: isSaving,
-            restrictedLibs: conf['restricted-libs'],
+            restrictedLibs: conf["restricted-libs"],
             webhooks: this.getCandidatedWebhook(fileName, conf),
-            commomModules
-        }
-        let url = `${this.config.colossus.url}`
-        const {data: responseData} = await this.http.post(url, data)
-
-        const {hookData} = responseData
-        if(hookData) {
-            const _webhooks = [...this.webhooks, hookData]
-            this.setWebhooks(_webhooks)
+            commomModules,
+        };
+        let url = `${this.config.colossus.url}`;
+        const { data: responseData } = await this.http.post(url, data);
+
+        const { hookData } = responseData;
+        if (hookData) {
+            const _webhooks = [...this.webhooks, hookData];
+            this.setWebhooks(_webhooks);
         }
-        return responseData
+        return responseData;
     }
 
     getCandidatedWebhook(fileName, conf) {
-        const webhooks = conf['webhooks']
-        if(!webhooks || webhooks.length === 0) return undefined
-        const fileIsCandidatedToWebhook = webhooks.some(hook => hook.fileName === fileName)
-        const hook = [{fileName}]
-        return fileIsCandidatedToWebhook ? hook : undefined
+        const webhooks = conf["webhooks"];
+        if (!webhooks || webhooks.length === 0) return undefined;
+        const fileIsCandidatedToWebhook = webhooks.some(
+            (hook) => hook.fileName === fileName
+        );
+        const hook = [{ fileName }];
+        return fileIsCandidatedToWebhook ? hook : undefined;
     }
 
     async isSynchronized() {
         const res = await Promise.all([
             this.hashFolder.calculate(),
             this.http.get(`${this.serverUrl}/${this.basePath}/fileupload`),
-        ])
-        const folderHashValue = res[0]['hash']
-        const serverHash = res[1]['hash']
-        return folderHashValue === serverHash
+        ]);
+        const folderHashValue = res[0]["hash"];
+        const serverHash = res[1]["hash"];
+        return folderHashValue === serverHash;
     }
 
     async rmAllServerFiles() {
-        await this.delete('/')
+        await this.delete("/");
     }
 
     async listFilesInCorrectOrder() {
-        const allFiles = await this.walk(this.folder2watch)
-        const componentsPath = path.join(this.folder2watch, 'components')
-        const componentTagRegExp = new RegExp(`${componentsPath}/[^/]+.jsx`)
-        const filesWithoutComponentTags = allFiles.filter(fileName => {
-            return !fileName.match(componentTagRegExp)
-        })
+        const allFiles = await this.walk(this.folder2watch);
+        const componentsPath = path.join(this.folder2watch, "components");
+        const componentTagRegExp = new RegExp(`${componentsPath}/[^/]+.jsx`);
+        const filesWithoutComponentTags = allFiles.filter((fileName) => {
+            return !fileName.match(componentTagRegExp);
+        });
         let files = filesWithoutComponentTags.sort((a, b) => {
-            if (a.includes('components') && !b.includes('components')) return -1
-            if (!a.includes('components') && b.includes('components')) return 1
-            if (a.includes('folder.hash')) return 1
-            if (b.includes('folder.hash')) return -1
-            return 0
-        })
-        const tagsFiles = await new TagTree().tagsFilesSorted(componentsPath)
-        files = tagsFiles.map(fileName => path.join(componentsPath, fileName)).concat(files)
-        return files
+            if (a.includes("components") && !b.includes("components"))
+                return -1;
+            if (!a.includes("components") && b.includes("components")) return 1;
+            if (a.includes("folder.hash")) return 1;
+            if (b.includes("folder.hash")) return -1;
+            return 0;
+        });
+        const tagsFiles = await new TagTree().tagsFilesSorted(componentsPath);
+        files = tagsFiles
+            .map((fileName) => path.join(componentsPath, fileName))
+            .concat(files);
+        return files;
     }
 
     async getAllResourceFiles(resources) {
-        let allFiles = []
-        resources.forEach(async dir => {
-            const files = await this.walk(dir)
-            allFiles.push(...files)
-        })
-        return allFiles
+        let allFiles = [];
+        resources.forEach(async (dir) => {
+            const files = await this.walk(dir);
+            allFiles.push(...files);
+        });
+        return allFiles;
     }
 
     async uploadAll() {
-        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch])
-        await this.rmAllServerFiles()
-        await this.hashFolder.updateHashFile()
+        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch]);
+        await this.rmAllServerFiles();
+        await this.hashFolder.updateHashFile();
 
-        const srcFiles = await this.listFilesInCorrectOrder()
-        const filesfromSrc = srcFiles.filter(f => !f.endsWith('folder.hash'))
-        const srcFolderHash = srcFiles.filter(f => f.endsWith('folder.hash'))
+        const srcFiles = await this.listFilesInCorrectOrder();
+        const filesfromSrc = srcFiles.filter((f) => !f.endsWith("folder.hash"));
+        const srcFolderHash = srcFiles.filter((f) => f.endsWith("folder.hash"));
 
-        const resourceFiles = await this.getAllResourceFiles(this.resourceFolders2watch)
+        const resourceFiles = await this.getAllResourceFiles(
+            this.resourceFolders2watch
+        );
 
-        let files = resourceFiles.concat(filesfromSrc)
-        const componentFiles = files.filter(file => file.includes('/components'))
+        let files = resourceFiles.concat(filesfromSrc);
+        const componentFiles = files.filter((file) =>
+            file.includes("/components")
+        );
 
         const opts = {
-            why: 'save',
+            why: "save",
             log: false,
             skipCompile: true,
+        };
+        const showProgressBar = true;
+        if (componentFiles && componentFiles.length > 0) {
+            await this.preUpsert(componentFiles, opts);
         }
-        const showProgressBar = true
-        if(componentFiles && componentFiles.length > 0) {
-            await this.preUpsert(componentFiles, opts)
-        }
-        await this.upsert(files, opts, showProgressBar)
-        await this.transpile(srcFolderHash)
+        await this.upsert(files, opts, showProgressBar);
+        await this.transpile(srcFolderHash);
     }
 
     async preUpsert(componentsFiles, opts) {
         for (const filePath of componentsFiles) {
-            await this.upsertSequencial(filePath, opts)
+            await this.upsertSequencial(filePath, opts);
         }
     }
 
     async uploadZip() {
-        const admZip = new AdmZip()
-        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch])
-        await this.rmAllServerFiles()
-        await this.hashFolder.updateHashFile()
-        const allFiles = await this.listFilesInCorrectOrder()
-        const files = allFiles.filter(f => !f.endsWith('folder.hash'))
-        const folderHash = allFiles.filter(f => f.endsWith('folder.hash'))
-        const commomModulesPaths = allFiles.filter(f => f.includes('src/commons'))
+        const admZip = new AdmZip();
+        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch]);
+        await this.rmAllServerFiles();
+        await this.hashFolder.updateHashFile();
+        const allFiles = await this.listFilesInCorrectOrder();
+        const files = allFiles.filter((f) => !f.endsWith("folder.hash"));
+        const folderHash = allFiles.filter((f) => f.endsWith("folder.hash"));
+        const commomModulesPaths = allFiles.filter((f) =>
+            f.includes("src/commons")
+        );
 
         for (let i = 0; i < files.length; i++) {
-            const filePath = files[i]
-            const filename = path.basename(filePath)
+            const filePath = files[i];
+            const filename = path.basename(filePath);
 
-            if (this.hasAccent(filename)) throw new Error(`Arquivo com um ou mais caracteres inválidos ${filename}`)
+            if (this.hasAccent(filename))
+                throw new Error(
+                    `Arquivo com um ou mais caracteres inválidos ${filename}`
+                );
 
-            const relativePath = this.getRelativePath(filePath)
+            const relativePath = this.getRelativePath(filePath);
             if (relativePath.startsWith(this.config.colossus.watchUserDir)) {
-                await this.postLambda(filePath, relativePath, false, commomModulesPaths)
+                await this.postLambda(
+                    filePath,
+                    relativePath,
+                    false,
+                    commomModulesPaths
+                );
             }
         }
 
-        admZip.addFile('__files_order.txt', allFiles.map(f => f.split(this.folder2watch)[1].replace(/\\/g, '/')).join('\n'))
-        admZip.addLocalFolder('./src')
+        admZip.addFile(
+            "__files_order.txt",
+            allFiles
+                .map((f) => f.split(this.folder2watch)[1].replace(/\\/g, "/"))
+                .join("\n")
+        );
+        admZip.addLocalFolder("./src");
 
-        console.log('Construindo')
+        console.log("Construindo");
 
-        const platform = process.platform
+        const platform = process.platform;
 
-        const zipPath = await this.resolveOs(platform)
-        admZip.writeZip(zipPath)
-        await this.sendZip(zipPath)
+        const zipPath = await this.resolveOs(platform);
+        admZip.writeZip(zipPath);
+        await this.sendZip(zipPath);
 
-        await this.transpile(folderHash)
+        await this.transpile(folderHash);
 
-        console.log('Pronto')
+        console.log("Pronto");
     }
 
     async resolveOs(platform) {
-        let tempDir = ''
+        let tempDir = "";
         if (tempFolderPath[platform]) {
-            tempDir = await tempFolderPath[platform]()
-        }
-        else {
-            tempDir = '.'
+            tempDir = await tempFolderPath[platform]();
+        } else {
+            tempDir = ".";
         }
-        return tempDir + '/miniApp.zip'
+        return tempDir + "/miniApp.zip";
     }
 
     async sendFiles(publishMessage) {
-        const miniConf = this.getMiniConf()
-        const formData = new FormData()
+        const miniConf = this.getMiniConf();
+        const formData = new FormData();
 
-        formData.append('miniAppName', miniConf.name || 'sem nome')
-        formData.append('miniAppSlug', miniConf.slug || 'sem-slug')
-        formData.append('miniAppTitle', miniConf.title || 'Sem Titulo')
-        formData.append('miniAppVersion', miniConf.miniAppVersion || miniConf.version || 'v1')
-        formData.append('organizationName', miniConf.organization.name)
-        formData.append('publishMessage', publishMessage || '')
+        formData.append("miniAppName", miniConf.name || "sem nome");
+        formData.append("miniAppSlug", miniConf.slug || "sem-slug");
+        formData.append("miniAppTitle", miniConf.title || "Sem Titulo");
+        formData.append(
+            "miniAppVersion",
+            miniConf.miniAppVersion || miniConf.version || "v1"
+        );
+        formData.append("organizationName", miniConf.organization.name);
+        formData.append("publishMessage", publishMessage || "");
 
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.postForm(url, formData)
+        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`;
+        await this.http.postForm(url, formData);
     }
 
     async sendZip(zip) {
-        const formData = new FormData()
-        formData.append('file', fs.createReadStream(zip))
-        const url = `${this.serverUrl}/${this.basePath}/uploadAll`
-        await this.http.postForm(url, formData)
+        const formData = new FormData();
+        formData.append("file", fs.createReadStream(zip));
+        const url = `${this.serverUrl}/${this.basePath}/uploadAll`;
+        await this.http.postForm(url, formData);
     }
 
     async transpile(files) {
         if (files.length > 0) {
             return await this.upsert(...files, {
-                why: 'uploadAll',
+                why: "uploadAll",
                 log: false,
-            })
+            });
         }
     }
 
     mkdirs(dirnames) {
         return new Promise((resolve, reject) => {
-            dirnames.forEach(dirname => {
+            dirnames.forEach((dirname) => {
                 fs.mkdir(dirname, { recursive: true }, (err) => {
                     if (err) {
-                        return reject(err)
+                        return reject(err);
                     }
-                    resolve()
-                })
-            })
-        })
+                    resolve();
+                });
+            });
+        });
     }
 
     async getFileNames(dir) {
-        const folder = path.resolve(this.folder2watch, dir)
-        const fileList = await this.walk(folder)
+        const folder = path.resolve(this.folder2watch, dir);
+        const fileList = await this.walk(folder);
 
-        const fileNames = fileList.map(filePath => {
-            return path.basename(filePath)
-        })
+        const fileNames = fileList.map((filePath) => {
+            return path.basename(filePath);
+        });
 
-        return fileNames
+        return fileNames;
     }
 
     async walk(dir) {
-        let results = []
-        const list = fs.readdirSync(dir)
+        let results = [];
+        const list = fs.readdirSync(dir);
         for (let i = 0; i < list.length; i++) {
-            let file = list[i]
-            file = path.join(dir, file)
-            const stat = fs.statSync(file)
+            let file = list[i];
+            file = path.join(dir, file);
+            const stat = fs.statSync(file);
             if (stat && stat.isDirectory()) {
                 /* Recurse into a subdirectory */
-                results = results.concat(await this.walk(file))
+                results = results.concat(await this.walk(file));
             } else {
                 /* Is a file */
-                results.push(file)
+                results.push(file);
             }
         }
-        return results
+        return results;
     }
 
     //TODO: ESSE MÉTODO DEVE SER APAGADO, QUANDO NÃO EXISTIR MAIS O COMANDO PUBLISH
     async publish(publishMessage) {
-        const miniConf = this.getMiniConf()
-        const formData = new FormData()
+        const miniConf = this.getMiniConf();
+        const formData = new FormData();
 
-        formData.append('miniAppName', miniConf.name || 'sem nome')
-        formData.append('miniAppSlug', miniConf.slug || 'sem-slug')
-        formData.append('miniAppTitle', miniConf.title || 'Sem Titulo')
-        formData.append('miniAppVersion', miniConf.miniAppVersion || miniConf.version || '0.1.0')
-        formData.append('organizationName', miniConf.organization.name)
-        formData.append('publishMessage', publishMessage || '')
+        formData.append("miniAppName", miniConf.name || "sem nome");
+        formData.append("miniAppSlug", miniConf.slug || "sem-slug");
+        formData.append("miniAppTitle", miniConf.title || "Sem Titulo");
+        formData.append(
+            "miniAppVersion",
+            miniConf.miniAppVersion || miniConf.version || "0.1.0"
+        );
+        formData.append("organizationName", miniConf.organization.name);
+        formData.append("publishMessage", publishMessage || "");
 
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.postForm(url, formData)
+        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`;
+        await this.http.postForm(url, formData);
     }
 
     async build(buildMessage) {
-        const miniConf = this.getMiniConf()
-        const formData = new FormData()
+        const miniConf = this.getMiniConf();
+        const formData = new FormData();
 
-        formData.append('miniAppName', miniConf.name || 'sem nome')
-        formData.append('miniAppSlug', miniConf.slug || 'sem-slug')
-        formData.append('miniAppTitle', miniConf.title || 'Sem Titulo')
-        formData.append('miniAppVersion', miniConf.miniAppVersion || miniConf.version || 'v1')
-        formData.append('organizationName', miniConf.organization.name)
-        formData.append('publishMessage', buildMessage || '')
+        formData.append("miniAppName", miniConf.name || "sem nome");
+        formData.append("miniAppSlug", miniConf.slug || "sem-slug");
+        formData.append("miniAppTitle", miniConf.title || "Sem Titulo");
+        formData.append(
+            "miniAppVersion",
+            miniConf.miniAppVersion || miniConf.version || "v1"
+        );
+        formData.append("organizationName", miniConf.organization.name);
+        formData.append("publishMessage", buildMessage || "");
 
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.postForm(url, formData)
+        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`;
+        await this.http.postForm(url, formData);
     }
 
     /**
      * @deprecated Prefira {@link Workspace#pushVersionAsJson}
      */
     async pushVersionAsForm(buildMessage) {
-        const miniConf = this.getMiniConf()
-        const formData = new FormData()
-
-        let attrValue
-
-        formData.append('miniAppName', miniConf.name || 'sem nome')
-        formData.append('miniAppSlug', miniConf.slug || 'sem-slug')
-        formData.append('miniAppTitle', miniConf.title || 'Sem Titulo')
-        formData.append('miniAppVersion', miniConf.miniAppVersion || miniConf.version || 'v1')
-        formData.append('organizationName', miniConf.organization.name)
-        formData.append('miniAppSubSetName', miniConf.name)
-        formData.append('miniAppSubSetTitle', miniConf.title)
-        if ((attrValue = miniConf['eitri-app-components'])) formData.append('cliComponentsVersion', attrValue)
-        if ((attrValue = miniConf['eitri-app-client'])) formData.append('cliSuperAppClientVersion', attrValue)
-        if ((attrValue = packageJson.version)) formData.append('cliVersion', attrValue)
-        if ((attrValue = buildMessage)) formData.append('publishMessage', attrValue)
-        if ((attrValue = miniConf.privacy)) formData.append('privacy', JSON.stringify(attrValue))
-
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.postForm(url, formData)
-    }
-
-    async pushVersionAsJson(buildMessage) {
-        let headers = {}
-        if(this.config.apiVersion && this.config.apiVersion.v2Header) {
+        const miniConf = this.getMiniConf();
+        const formData = new FormData();
+
+        let attrValue;
+
+        formData.append("miniAppName", miniConf.name || "sem nome");
+        formData.append("miniAppSlug", miniConf.slug || "sem-slug");
+        formData.append("miniAppTitle", miniConf.title || "Sem Titulo");
+        formData.append(
+            "miniAppVersion",
+            miniConf.miniAppVersion || miniConf.version || "v1"
+        );
+        formData.append("organizationName", miniConf.organization.name);
+        formData.append("miniAppSubSetName", miniConf.name);
+        formData.append("miniAppSubSetTitle", miniConf.title);
+        if ((attrValue = miniConf["eitri-app-components"]))
+            formData.append("cliComponentsVersion", attrValue);
+        if ((attrValue = miniConf["eitri-app-client"]))
+            formData.append("cliSuperAppClientVersion", attrValue);
+        if ((attrValue = packageJson.version))
+            formData.append("cliVersion", attrValue);
+        if ((attrValue = buildMessage))
+            formData.append("publishMessage", attrValue);
+        if ((attrValue = miniConf.privacy))
+            formData.append("privacy", JSON.stringify(attrValue));
+
+        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`;
+        await this.http.postForm(url, formData);
+    }
+
+    async pushVersionAsJson(args) {
+        let headers = {};
+        if (this.config.apiVersion && this.config.apiVersion.v2Header) {
             headers = {
-                'accept': this.config.apiVersion.v2Header
-            }
+                accept: this.config.apiVersion.v2Header,
+            };
         }
-        const miniConf = this.getMiniConf()
-        const body = { miniConf, buildMessage, cliVersion: packageJson.version }
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.post(url, body, headers)
+        const miniConf = this.getMiniConf();
+        const body = {
+            miniConf,
+            buildMessage: args.message,
+            cliVersion: packageJson.version,
+            eitriAppType: args.components ? 'COMPONENTS' : 'APPLICATION'
+        };
+        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`;
+        await this.http.post(url, body, headers);
     }
 
     async create(conf) {
-        const url = `${this.serverUrl}/${this.basePath}/create`
-        return await this.http.post(url, conf)
-            .then(res => res.data)
-            .catch(err => {
-                if (err.isAxiosError && err.response && err.response.status === 409 && err.response.data && err.response.data.error) {
-                    console.log('Error: ' + err.response.data.error)
-                    let dupError = new Error(err.response.data.error)
-                    dupError.isDuplicatedError = true
-                    dupError.field = err.response.data.field
-                    throw dupError
+        const url = `${this.serverUrl}/${this.basePath}/create`;
+        return await this.http
+            .post(url, conf)
+            .then((res) => res.data)
+            .catch((err) => {
+                if (
+                    err.isAxiosError &&
+                    err.response &&
+                    err.response.status === 409 &&
+                    err.response.data &&
+                    err.response.data.error
+                ) {
+                    console.log("Error: " + err.response.data.error);
+                    let dupError = new Error(err.response.data.error);
+                    dupError.isDuplicatedError = true;
+                    dupError.field = err.response.data.field;
+                    throw dupError;
                 }
-                console.log(err.message)
+                console.log(err.message);
                 if (err && err.response) {
-                    console.log(err.response.data)
+                    console.log(err.response.data);
                 }
-                throw err
-            })
+                throw err;
+            });
     }
 
     async applyRolloutEnvironmentIfNeeded() {
-        const start = Date.now()
+        const start = Date.now();
         try {
-            const { slug } = this.getMiniConf()
-            const url = `${this.serverUrl}/${this.basePath}/users/miniapps/${slug}/actions/WORKSPACE_ROLLOUT`
-            const response = await this.http.get(url)
+            const { slug } = this.getMiniConf();
+            const url = `${this.serverUrl}/${this.basePath}/users/miniapps/${slug}/actions/WORKSPACE_ROLLOUT`;
+            const response = await this.http.get(url);
             if (response.result) {
-                process.env['NODE_ENV'] = 'beta'
-                this.rollout = response.result
+                process.env["NODE_ENV"] = "beta";
+                this.rollout = response.result;
 
-                console.log('\n')
-                console.log('\t╔═══════════════════════════════════════╗')
-                console.log('\t║ Atenção: Utilizando Beta Workspace    ║')
-                console.log('\t╚═══════════════════════════════════════╝\n')
+                console.log("\n");
+                console.log("\t╔═══════════════════════════════════════╗");
+                console.log("\t║ Atenção: Utilizando Beta Workspace    ║");
+                console.log("\t╚═══════════════════════════════════════╝\n");
             }
         } catch (e) {
-            if (process.env.LOG_LEVEL === 'full') {
-                console.log(e)
+            if (process.env.LOG_LEVEL === "full") {
+                console.log(e);
             }
         }
 
-        if (process.env.LOG_LEVEL === 'full') {
-            console.log('Check rollout time', Date.now() - start)
+        if (process.env.LOG_LEVEL === "full") {
+            console.log("Check rollout time", Date.now() - start);
         }
     }
 
     isRollout() {
-        return this.rollout
+        return this.rollout;
     }
 
     // bff
     async availableTargets() {
-        if(this.getTargets().length === 0) {
-            const url = `${this.serverUrl}/${this.basePath}/targets`
-            const options = {
-                headers: {
-                    'Accept': 'application/vnd.workspace.api.v2+json'
-                }
-            }
-            const targets = await this.http.get(url, options)
-            this.setTargets(targets)
-            return targets
+        if (this.getTargets().length === 0) {
+            const targets = await new EitriAppManager(
+                this.blindGuardian
+            ).findAllApplications();
+            this.setTargets(targets);
+            return targets;
         }
-        return this.getTargets()
+        return this.getTargets();
     }
 
     // local
     getKnownAvailableTargets() {
-        return this.config.target.knownTargets
+        return this.config.target.knownTargets;
     }
 
     async getDefaultTarget() {
-        await this.availableTargets()
-        return this.getTargets().find(value => value.default)
+        await this.availableTargets();
+        return this.getTargets().find((value) => value.default);
     }
 
     // client http configurado conforme as necessidades do workspace
     getHttp() {
-        return this.http
+        return this.http;
     }
 
     async comparePermissions(target) {
-        const miniConf = this.getMiniConf()
-        const permissions = miniConf.permissions || []
-        const permissionsWithTarget = permissions.map(permission => ({...permission, target}))
-        const slug = miniConf.slug
-        const {data} = await this.http.post(`${this.serverUrl}/${this.basePath}/miniapps/${slug}/permissions/compare`, permissionsWithTarget)
-        const addedPermissions = []
-        const removedPermissions = []
-        if(data.diffCount > 0) {
-            data.result.forEach(result => {
-                if(result.status === 'added') {
-                    addedPermissions.push(result.entity.permission)
+        const miniConf = this.getMiniConf();
+        const permissions = miniConf.permissions || [];
+        const permissionsWithTarget = permissions.map((permission) => ({
+            ...permission,
+            target,
+        }));
+        const slug = miniConf.slug;
+        const { data } = await this.http.post(
+            `${this.serverUrl}/${this.basePath}/miniapps/${slug}/permissions/compare`,
+            permissionsWithTarget
+        );
+        const addedPermissions = [];
+        const removedPermissions = [];
+        if (data.diffCount > 0) {
+            data.result.forEach((result) => {
+                if (result.status === "added") {
+                    addedPermissions.push(result.entity.permission);
                 } else {
-                    removedPermissions.push(result.entity.permission)
+                    removedPermissions.push(result.entity.permission);
                 }
-            })
+            });
         }
-        return {addedPermissions, removedPermissions}
+        return { addedPermissions, removedPermissions };
     }
 
     async clean() {
-        await this.getHttp().delete(`${this.serverUrl}/${this.basePath}/sources`, {})
+        await this.getHttp().delete(
+            `${this.serverUrl}/${this.basePath}/sources`,
+            {}
+        );
     }
 
     compressCode(code) {
-        const {SERVERLESS_CODE_COMPRESSION: compressionType, LOG_LEVEL} = process.env
-
-        let compressedCode, codeLength = code.length
-        let maxPreviewLenth = 50
-        let previewLength = codeLength > maxPreviewLenth ? maxPreviewLenth : codeLength
-
-        if(compressionType === 'base64') {
-            compressedCode = this.toBase64(code)
-
-            if(LOG_LEVEL === 'full') {
-                console.log(`Enviando arquivo sem compactacao em base64: ${code.substring(0, previewLength)}, codeLenth: ${codeLength}`)
+        const { SERVERLESS_CODE_COMPRESSION: compressionType, LOG_LEVEL } =
+            process.env;
+
+        let compressedCode,
+            codeLength = code.length;
+        let maxPreviewLenth = 50;
+        let previewLength =
+            codeLength > maxPreviewLenth ? maxPreviewLenth : codeLength;
+
+        if (compressionType === "base64") {
+            compressedCode = this.toBase64(code);
+
+            if (LOG_LEVEL === "full") {
+                console.log(
+                    `Enviando arquivo sem compactacao em base64: ${code.substring(
+                        0,
+                        previewLength
+                    )}, codeLenth: ${codeLength}`
+                );
             }
-        } else if(compressionType === 'none'){
-            if(LOG_LEVEL === 'full') {
-                console.log(`Enviando arquivo sem qualquer compressao: ${code.substring(0, previewLength)}, codeLenth: ${codeLength}`)
+        } else if (compressionType === "none") {
+            if (LOG_LEVEL === "full") {
+                console.log(
+                    `Enviando arquivo sem qualquer compressao: ${code.substring(
+                        0,
+                        previewLength
+                    )}, codeLenth: ${codeLength}`
+                );
             }
-        } else if (!compressionType || compressionType === 'shrink') {
-            compressedCode = compressToBase64(code)
-
-            if(LOG_LEVEL === 'full') {
-                console.log(`File preview: ${code.substring(0, previewLength)}, Before compression: ${codeLength}, After compression: ${compressedCode.length}`)
+        } else if (!compressionType || compressionType === "shrink") {
+            compressedCode = compressToBase64(code);
+
+            if (LOG_LEVEL === "full") {
+                console.log(
+                    `File preview: ${code.substring(
+                        0,
+                        previewLength
+                    )}, Before compression: ${codeLength}, After compression: ${
+                        compressedCode.length
+                    }`
+                );
             }
         }
 
-
-        return { code: compressedCode || code, compressionType: compressionType || 'shrink' }
+        return {
+            code: compressedCode || code,
+            compressionType: compressionType || "shrink",
+        };
     }
 
     toBase64(content) {
-        return Buffer.from(content).toString('base64')
+        return Buffer.from(content).toString("base64");
     }
 
     createProgressBar(showProgressBar) {
-        if(showProgressBar) {
+        if (showProgressBar) {
             this.progressBar = new cliProgress.SingleBar(
                 {
-                    format:
-                        'Sincronizando [{bar}] {percentage}% | ETA: {eta}s | {value}/{total} Arquivos sincronizados...',
+                    format: "Sincronizando [{bar}] {percentage}% | ETA: {eta}s | {value}/{total} Arquivos sincronizados...",
                 },
-                cliProgress.Presets.shades_classic,
-            )
+                cliProgress.Presets.shades_classic
+            );
         }
     }
 
     /**
-     * 
-     * @param {unknown[]} array 
-     * @param {number} chunkCount 
+     *
+     * @param {unknown[]} array
+     * @param {number} chunkCount
      * @returns {unknown[][]}
      */
-    spliceArray(array, chunkCount){
-        var chunks = [],  iterator, auxiliar
-        for (iterator = 0, auxiliar = array.length; iterator < auxiliar; iterator += chunkCount) {
-            chunks.push(array.slice(iterator, iterator + chunkCount)) 
+    spliceArray(array, chunkCount) {
+        var chunks = [],
+            iterator,
+            auxiliar;
+        for (
+            iterator = 0, auxiliar = array.length;
+            iterator < auxiliar;
+            iterator += chunkCount
+        ) {
+            chunks.push(array.slice(iterator, iterator + chunkCount));
         }
-        return chunks
+        return chunks;
     }
-
 }
 
 module.exports = {
     workspace: new Workspace(new BlindGuardian(), new HashFolder()),
-    Workspace
-}
+    Workspace,
+};