eitri-cli 1.0.2

package/src/service/Workspace.js

@@ -0,0 +1,1069 @@
+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')
+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
+        if (!this.config.colossus) {
+            console.warn('Missing colossus config inside workspace.')
+        }
+        this.shareApi = config.get('shareApi')
+        this.webhooks = []
+        this.targets = []
+
+        /**
+         * @type {cliProgress.SingleBar}
+         * @private
+         */
+        this.progressBar
+        this.progressBarCounter = 0
+    }
+
+    getTargets() {
+        return this.targets
+    }
+
+    setTargets(targets) {
+        this.targets = targets
+    }
+
+    getWebhooks () {
+        return this.webhooks
+    }
+
+    setWebhooks(webhooks) {
+        this.webhooks = webhooks
+    }
+
+    setServerUrl(url) {
+        this.serverUrl = url
+    }
+
+    setQrCodeUrl(qrCodeUrl) {
+        this.qrCodeUrl = qrCodeUrl
+    }
+
+    setFolder2Watch(folderPath) {
+        this.folder2watch = folderPath
+    }
+
+    setResourceFolder2Watch(resourceFolders2watch) {
+        this.resourceFolders2watch = resourceFolders2watch
+    }
+
+    getResourceFolder2Watch() {
+        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)
+            }
+        
+            return [config]
+        } catch (e) {
+            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
+        } catch (e) {
+            console.log(`Erro ao buscar configuração: ${e}`)
+            process.exit(1)
+        }
+    }
+
+    getTarget() {
+
+        if(!this.target) {
+            console.warn('Target não foi detectado no setup()')
+        }
+
+        return this.target
+    }
+
+    async init() {
+        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')
+            if (!fs.existsSync(miniAppConfPath)) {
+                throw new Error('Por favor, verifique se você está dentro da pasta de um projeto eitri-app.')
+            }
+            this._miniConf = require(miniAppConfPath)
+            if (!this._miniConf.version) {
+                throw Error('Arquivo miniapp.conf.js sem version')
+            }
+        }
+        return this._miniConf
+    }
+
+    setMiniConf(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)
+                }
+                resolve()
+            })
+        })
+    }
+
+    async setup() {
+        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
+
+        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
+
+        this.printLibsVersion(state)
+
+        await this.loadTarget(remoteTarget)
+
+        return setupData
+    }
+
+    async loadTarget(remoteTarget) {
+        const targets = await this.availableTargets()
+        this.target = targets.find(t => t.name === remoteTarget.name)
+
+        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]
+            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]*))/)
+                if (m) {
+                    version = m[1]
+                }
+                libVersionsOutput += `      ${lib.name} [${version}]\n`
+            }
+        })
+        console.log(libVersionsOutput)
+    }
+
+    async checkVersions() {
+        try {
+            const miniConf = this.getMiniConf()
+            const headers = {
+                '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}
+        } catch (error) {
+            console.log(`\x1b[1m\x1b[31m${error.message}\x1b[0m`);
+            process.exit(1)
+        }
+    }
+
+    isDiff(miniConf, onlineVersion, packageName) {
+        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'
+        let miniAppData = {
+            developerEmail: this.userEmail,
+            environment: environment,
+            albCookie: cookie.cookieString(),
+            orderId: args.orderId,
+            shareId: args.shareId,
+            slug: miniConf.slug,
+            publicKey: miniConf['public-key'] || miniConf.publicKey,
+            view: viewHtml
+        }
+        // delete miniAppData.albCookie
+        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()
+        const data = {
+            publicKey: miniAppConf['public-key'],
+            metadata: miniAppConf['metadata'],
+            slug: miniAppConf['slug'],
+            title: miniAppConf['title']
+        }
+        if (args.orderId) {
+            paramOrderId = '&orderId=' + encodeURIComponent(args.orderId)
+        }
+        if (args.shareId) {
+            paramShareId = '&shareId=' + encodeURIComponent(args.shareId)
+        }
+        if (args.initializationParams) {
+            data.initializationParams = args.initializationParams
+        }
+        const encodedData = Base64.encode(JSON.stringify(data))
+        if (cookie) {
+            cid = Base64.encode(cookie.cookieString())
+        }
+
+        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`
+
+        if (cid) {
+            miniAppUrl = miniAppUrl + '&cid=' + cid
+        }
+        return miniAppUrl
+    }
+
+    /**
+     * 
+     * @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}`
+        }
+        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'}`
+        return {
+            miniAppConf: {
+                ...qrCodeConfig,
+                shareId: stateId
+            },
+            miniAppUrl
+        }
+    }
+
+    async saveShareState(qrCodeConfig) {
+        const createWorkspaceStateUrl = `${this.serverUrl}/${this.basePath}/share`
+        const requestBody = {
+            id: uuidv4(),
+            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
+
+        if (cookie) {
+            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'],
+
+            // Se nao enviarmos essa url pronta, o superapp tera que monta-la
+            // Essa url chama a funcao users.js do workspace-api
+            miniAppBootstrapUrl: await this.getWorkspaceURL(args, targetConfig),
+            initializationParams,
+            orderId,
+            view,
+            extras: {
+                cid // superapp joga tudo do extras na query string do bootstrapUrl .... Pq ja nao mandamos na queryString ja daqui?
+            }
+        }
+
+        return config
+    }
+
+    getRelativePath(filePath) {
+        return filePath
+            .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 params = {
+            filepath: relPath,
+        }
+        await this.http.delete(url, { params })
+    }
+
+    hasAccent(fileName) {
+        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)
+        }
+        return await this.upsertSequencial(filesPath, opts)
+    }
+
+    async upsertSequencial(filePath, opts = {}) {
+        const fileName = path.basename(filePath)
+
+        const {isInvalid, promise} = await this.validateFileName(fileName, filePath)
+        if(isInvalid) return await promise
+
+        const holder = this.createPromiseHolder()
+        this.upsertQueue.push({
+            filePath,
+            opts,
+            holder,
+            requestNumber: this.requestNumber++,
+        })
+
+        const isSaving = opts.why === WatcherOpts.SAVE
+
+        if (!this.uploading) {
+            await this.execUpsertSequencial(isSaving)
+        }
+
+        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)
+        }
+            
+        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))   
+        }
+    
+        const promisesChunks = this.spliceArray(promises, 5)
+        const data = []
+        for (const promiseArray of promisesChunks) {
+            const result = await Promise.all(promiseArray)
+            data.push(...result)
+        }
+
+        if(isSaving) return data[0]
+
+        if(showProgressBar) {
+            this.progressBar.update(filesPath.length)
+            this.progressBar.stop()
+        }
+        return data
+    }
+
+    async postFile(filePath, isSaving, opts) {
+        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)
+        } else {
+            await this.postFormData(filePath, relativePath, opts)
+        }
+        return {
+            start,
+            relativePath,
+            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)
+        }
+        return {
+            filePath,
+            relativePath,
+            requestNumber,
+            time: new Date().getTime() - start,
+            baseName: fileName
+        }
+        
+    }
+
+    async execUpsertSequencial(isSaving) {
+        this.uploading = true
+        for (let i = 0; i < this.upsertQueue.length; i++) {
+            const { filePath, opts, holder, requestNumber } = this.upsertQueue[i]
+
+            try {
+                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
+            }
+        }
+        this.upsertQueue = []
+        this.uploading = false
+    }
+
+    async validateFileName(fileName, filePath) {
+        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)
+
+            promise = Promise.resolve({
+                filePath,
+                relativePath: this.getRelativePath(filePath),
+                time: 0,
+                requestNumber: this.requestNumber++,
+                message
+            })
+        }
+        return {
+            isInvalid: hasAccent,
+            promise
+        }
+    }
+
+    createPromiseHolder() {
+        const holder = {}
+        holder.promise = new Promise((resolve, reject) => {
+            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)
+        if (opts.forceTranspile) {
+            formData.append('forceTranspile', opts.forceTranspile)
+        }
+        const url = `${this.serverUrl}/${this.basePath}/fileupload`
+        return await this.http.postForm(url, formData)
+    }
+
+    getEnvCode() {
+        if (!this.publishing) {
+            return 'ws'
+        }
+        if ([ 'dev', 'loc' ].includes(process.env.NODE_ENV)) {
+            return 'dev'
+        } else {
+            return 'hml'
+        }
+    }
+
+    async postLambda(filePath, relativePath, isSaving, commomModulesPaths = []) {
+
+        let commomModules = commomModulesPaths.map(commomFilePath => {
+            let code = fs.readFileSync(commomFilePath, 'utf8')
+
+            let name = path.basename(commomFilePath)
+
+            let compressionResult = this.compressCode(code)
+
+            return { name, ...compressionResult }
+        })
+
+        let code = fs.readFileSync(filePath, 'utf8')
+
+        let compressionResult = this.compressCode(code)
+
+        let conf = this.getMiniConf()
+        const envCode = this.getEnvCode()
+        const fileName = path.basename(relativePath)
+        let data = {
+            slug: conf.slug,
+            envCode: envCode,
+            miniAppVersion: conf.version,
+            name: fileName,
+            code: compressionResult.code,
+            compressionType: compressionResult.compressionType,
+            publishing: this.publishing,
+            isSaving: isSaving,
+            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)
+        }
+        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
+    }
+
+    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
+    }
+
+    async rmAllServerFiles() {
+        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)
+        })
+        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
+    }
+
+    async getAllResourceFiles(resources) {
+        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()
+
+        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)
+
+        let files = resourceFiles.concat(filesfromSrc)
+        const componentFiles = files.filter(file => file.includes('/components'))
+
+        const opts = {
+            why: 'save',
+            log: false,
+            skipCompile: true,
+        }
+        const showProgressBar = true
+        if(componentFiles && componentFiles.length > 0) {
+            await this.preUpsert(componentFiles, opts)
+        }
+        await this.upsert(files, opts, showProgressBar)
+        await this.transpile(srcFolderHash)
+    }
+
+    async preUpsert(componentsFiles, opts) {
+        for (const filePath of componentsFiles) {
+            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'))
+
+        for (let i = 0; i < files.length; i++) {
+            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}`)
+
+            const relativePath = this.getRelativePath(filePath)
+            if (relativePath.startsWith(this.config.colossus.watchUserDir)) {
+                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')
+
+        console.log('Construindo')
+
+        const platform = process.platform
+
+        const zipPath = await this.resolveOs(platform)
+        admZip.writeZip(zipPath)
+        await this.sendZip(zipPath)
+
+        await this.transpile(folderHash)
+
+        console.log('Pronto')
+    }
+
+    async resolveOs(platform) {
+        let tempDir = ''
+        if (tempFolderPath[platform]) {
+            tempDir = await tempFolderPath[platform]()
+        }
+        else {
+            tempDir = '.'
+        }
+        return tempDir + '/miniApp.zip'
+    }
+
+    async sendFiles(publishMessage) {
+        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 || '')
+
+        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)
+    }
+
+    async transpile(files) {
+        if (files.length > 0) {
+            return await this.upsert(...files, {
+                why: 'uploadAll',
+                log: false,
+            })
+        }
+    }
+
+    mkdirs(dirnames) {
+        return new Promise((resolve, reject) => {
+            dirnames.forEach(dirname => {
+                fs.mkdir(dirname, { recursive: true }, (err) => {
+                    if (err) {
+                        return reject(err)
+                    }
+                    resolve()
+                })
+            })
+        })
+    }
+
+    async getFileNames(dir) {
+        const folder = path.resolve(this.folder2watch, dir)
+        const fileList = await this.walk(folder)
+
+        const fileNames = fileList.map(filePath => {
+            return path.basename(filePath)
+        })
+
+        return fileNames
+    }
+
+    async walk(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)
+            if (stat && stat.isDirectory()) {
+                /* Recurse into a subdirectory */
+                results = results.concat(await this.walk(file))
+            } else {
+                /* Is a file */
+                results.push(file)
+            }
+        }
+        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()
+
+        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)
+    }
+
+    async build(buildMessage) {
+        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 || '')
+
+        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) {
+            headers = {
+                '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)
+    }
+
+    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
+                }
+                console.log(err.message)
+                if (err && err.response) {
+                    console.log(err.response.data)
+                }
+                throw err
+            })
+    }
+
+    async applyRolloutEnvironmentIfNeeded() {
+        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)
+            if (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')
+            }
+        } catch (e) {
+            if (process.env.LOG_LEVEL === 'full') {
+                console.log(e)
+            }
+        }
+
+        if (process.env.LOG_LEVEL === 'full') {
+            console.log('Check rollout time', Date.now() - start)
+        }
+    }
+
+    isRollout() {
+        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
+        }
+        return this.getTargets()
+    }
+
+    // local
+    getKnownAvailableTargets() {
+        return this.config.target.knownTargets
+    }
+
+    async getDefaultTarget() {
+        await this.availableTargets()
+        return this.getTargets().find(value => value.default)
+    }
+
+    // client http configurado conforme as necessidades do workspace
+    getHttp() {
+        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)
+                } else {
+                    removedPermissions.push(result.entity.permission)
+                }
+            })
+        }
+        return {addedPermissions, removedPermissions}
+    }
+
+    async clean() {
+        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}`)
+            }
+        } 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}`)
+            }
+        }
+
+
+        return { code: compressedCode || code, compressionType: compressionType || 'shrink' }
+    }
+
+    toBase64(content) {
+        return Buffer.from(content).toString('base64')
+    }
+
+    createProgressBar(showProgressBar) {
+        if(showProgressBar) {
+            this.progressBar = new cliProgress.SingleBar(
+                {
+                    format:
+                        'Sincronizando [{bar}] {percentage}% | ETA: {eta}s | {value}/{total} Arquivos sincronizados...',
+                },
+                cliProgress.Presets.shades_classic,
+            )
+        }
+    }
+
+    /**
+     * 
+     * @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)) 
+        }
+        return chunks
+    }
+
+}
+
+module.exports = {
+    workspace: new Workspace(new BlindGuardian(), new HashFolder()),
+    Workspace
+}