jatai 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7061adcfd38cb77a83a6807ac0295ac0699b515f496bb62e508e1eb024ba8779
+  data.tar.gz: f445036041493a7e51e316eba1258fab565abd8d3df444e9ec5ad88f28a8c22e
+SHA512:
+  metadata.gz: a0a35dfe41431ef623bc0e2ff937304682e0237417105054df3d82deabd5df3d8808d007f03753dae54f11f9a6e7255555fca44b26119b95fae780679e5f88e0
+  data.tar.gz: 58b87cf0501262214add03bae6dd12f1b778cba3f43d8666db18049ffc0fee728298759207e3bf2a41b47cb8939f4afa37448d15dfa8f4bc2a1e51703b83e639

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Brasa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# Jatai CLI
+
+CLI para deploy de aplicações na nuvem brasileira (Magalu Cloud). Soberania de dados, faturamento em reais.
+
+## Instalacao
+
+```bash
+gem install jatai
+```
+
+## Quick Start
+
+```bash
+# Autenticar na plataforma
+jatai login
+
+# Inicializar projeto (cria .jatai.yml)
+jatai init
+
+# Criar app e fazer primeiro deploy
+jatai up
+```
+
+## Comandos
+
+| Comando | Descricao |
+|---------|-----------|
+| `jatai login` | Autenticar na plataforma |
+| `jatai init` | Inicializar projeto no diretorio atual |
+| `jatai up` | Criar app e fazer primeiro deploy |
+| `jatai deploy` | Fazer deploy da aplicacao |
+| `jatai status` | Ver status da aplicacao |
+| `jatai logs` | Ver logs da aplicacao |
+| `jatai env list` | Listar variaveis de ambiente |
+| `jatai env set KEY=VALUE` | Definir variavel de ambiente |
+| `jatai env unset KEY` | Remover variavel de ambiente |
+| `jatai db info` | Informacoes do banco de dados |
+| `jatai db backup` | Criar backup do banco |
+| `jatai db restore BACKUP_ID` | Restaurar backup |
+| `jatai domains list` | Listar dominios customizados |
+| `jatai domains add HOSTNAME` | Adicionar dominio |
+| `jatai domains remove HOSTNAME` | Remover dominio |
+| `jatai domains verify HOSTNAME` | Verificar dominio |
+| `jatai scale` | Escalar a aplicacao |
+| `jatai destroy` | Destruir aplicacao e recursos |
+| `jatai version` | Exibir versao da CLI |
+
+## Configuracao
+
+O comando `jatai init` cria um arquivo `.jatai.yml` na raiz do projeto:
+
+```yaml
+app: meu-app
+stack: rails
+```
+
+## Variaveis de Ambiente
+
+| Variavel | Descricao | Padrao |
+|----------|-----------|--------|
+| `JATAI_API_URL` | URL da API | `https://api.usebrasa.com.br` |
+
+## Licenca
+
+MIT License - veja [LICENSE.txt](LICENSE.txt).

data/exe/jatai

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "jatai"
+
+Jatai::CLI.start(ARGV)

data/lib/jatai/api/client.rb

@@ -0,0 +1,108 @@
+require "faraday"
+require "faraday/multipart"
+require "json"
+
+module Jatai
+  module Api
+    class Client
+      class ApiError < StandardError
+        attr_reader :status, :body
+
+        def initialize(message, status: nil, body: nil)
+          @status = status
+          @body = body
+          super(message)
+        end
+      end
+
+      class AuthenticationError < ApiError; end
+      class NotFoundError < ApiError; end
+      class ValidationError < ApiError; end
+
+      def initialize(token: nil, api_url: nil)
+        @token = token || Config.token
+        @api_url = api_url || Config.api_url
+      end
+
+      def get(path, params: {})
+        request(:get, path, params: params)
+      end
+
+      def post(path, body: {})
+        request(:post, path, body: body)
+      end
+
+      def put(path, body: {})
+        request(:put, path, body: body)
+      end
+
+      def patch(path, body: {})
+        request(:patch, path, body: body)
+      end
+
+      def delete(path)
+        request(:delete, path)
+      end
+
+      def upload(path, file_path:, params: {})
+        response = upload_connection.post(path) do |req|
+          req.body = params.merge(source: Faraday::Multipart::FilePart.new(file_path, "application/gzip"))
+        end
+        handle_response(response)
+      end
+
+      private
+
+      def upload_connection
+        @upload_connection ||= Faraday.new(url: @api_url) do |conn|
+          conn.request :multipart
+          conn.request :url_encoded
+          conn.response :json
+          conn.headers["Authorization"] = "Bearer #{@token}" if @token
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      def request(method, path, body: nil, params: nil)
+        response = connection.public_send(method, path) do |req|
+          req.params = params if params && !params.empty?
+          req.body = body.to_json if body
+        end
+        handle_response(response)
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: @api_url) do |conn|
+          conn.request :json
+          conn.response :json
+          conn.headers["Content-Type"] = "application/json"
+          conn.headers["Authorization"] = "Bearer #{@token}" if @token
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200..299
+          response.body
+        when 401
+          raise AuthenticationError.new("Não autenticado. Execute `jatai login`.", status: 401, body: response.body)
+        when 404
+          raise NotFoundError.new("Recurso não encontrado.", status: 404, body: response.body)
+        when 403
+          msg = response.body&.dig("error") || "Sem permissão para esta ação"
+          raise ApiError.new(msg, status: 403, body: response.body)
+        when 409
+          msg = response.body&.dig("error") || "Conflito — recurso já existe ou operação em andamento"
+          raise ApiError.new(msg, status: 409, body: response.body)
+        when 422
+          msg = response.body&.dig("errors")&.join(", ") || response.body&.dig("error") || "Dados inválidos"
+          raise ValidationError.new(msg, status: 422, body: response.body)
+        else
+          msg = response.body&.dig("error") || "Erro na API (#{response.status})"
+          raise ApiError.new(msg, status: response.status, body: response.body)
+        end
+      end
+    end
+  end
+end

data/lib/jatai/cli.rb

@@ -0,0 +1,106 @@
+require "thor"
+require "jatai/commands/login"
+require "jatai/commands/init"
+require "jatai/commands/up"
+require "jatai/commands/deploy"
+require "jatai/commands/logs"
+require "jatai/commands/logs_search"
+require "jatai/commands/logs_export"
+require "jatai/commands/env"
+require "jatai/commands/database"
+require "jatai/commands/scale"
+require "jatai/commands/status"
+require "jatai/commands/destroy"
+require "jatai/commands/domains"
+require "jatai/commands/redis"
+
+module Jatai
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "login", "Autenticar na plataforma Jatai"
+    def login
+      Commands::Login.new.execute
+    end
+
+    desc "init", "Inicializar projeto no diretório atual"
+    def init
+      Commands::Init.new.execute
+    end
+
+    desc "up", "Criar app e fazer primeiro deploy"
+    def up
+      Commands::Up.new.execute
+    end
+
+    desc "deploy", "Fazer deploy da aplicação"
+    option :branch, type: :string, desc: "Branch para deploy"
+    def deploy
+      Commands::Deploy.new.execute(options)
+    end
+
+    desc "logs", "Ver logs da aplicação em tempo real"
+    option :tail, type: :numeric, default: 100, desc: "Número de linhas"
+    def logs
+      Commands::Logs.new.execute(options)
+    end
+
+    desc "logs:search", "Buscar nos logs da aplicação"
+    option :query, type: :string, required: true, desc: "Termo de busca"
+    option :level, type: :string, desc: "Filtrar por nível (error, warn, info)"
+    option :source, type: :string, desc: "Filtrar por source"
+    option :since, type: :string, desc: "Período (ex: 1h, 24h, 7d)"
+    option :limit, type: :string, default: "100", desc: "Limite de resultados"
+    define_method("logs:search") do
+      Commands::LogsSearch.new.execute(options)
+    end
+
+    desc "logs:export", "Exportar logs da aplicação"
+    option :format, type: :string, default: "json", desc: "Formato de exportação (json, csv)"
+    option :since, type: :string, desc: "Data/hora inicial"
+    option :until, type: :string, desc: "Data/hora final"
+    option :level, type: :string, desc: "Filtrar por nível (error, warn, info)"
+    define_method("logs:export") do
+      Commands::LogsExport.new.execute(options)
+    end
+
+    desc "env SUBCOMMAND", "Gerenciar variáveis de ambiente"
+    subcommand "env", Commands::Env
+
+    desc "db SUBCOMMAND", "Gerenciar banco de dados"
+    subcommand "db", Commands::Database
+
+    desc "domains SUBCOMMAND", "Gerenciar domínios customizados"
+    subcommand "domains", Commands::Domains
+
+    desc "redis SUBCOMMAND", "Gerenciar Redis cache"
+    subcommand "redis", Commands::Redis
+
+    desc "scale", "Escalar a aplicação"
+    option :replicas, type: :numeric, desc: "Número de réplicas"
+    option :preset, type: :string, desc: "Preset (micro, hobby, pro)"
+    def scale
+      Commands::Scale.new.execute(options)
+    end
+
+    desc "status", "Ver status da aplicação"
+    def status
+      Commands::Status.new.execute
+    end
+
+    desc "destroy", "Destruir aplicação e recursos"
+    def destroy
+      Commands::Destroy.new.execute
+    end
+
+    desc "version", "Exibir versão da CLI"
+    def version
+      puts "jatai #{Jatai::VERSION}"
+    end
+
+    map "-v" => :version
+    map "--version" => :version
+  end
+end

data/lib/jatai/commands/base.rb

@@ -0,0 +1,47 @@
+require "yaml"
+require "pastel"
+
+module Jatai
+  module Commands
+    class Base
+      def pastel
+        @pastel ||= Pastel.new
+      end
+
+      def api
+        @api ||= Api::Client.new
+      end
+
+      def project_config
+        @project_config ||= begin
+          config_path = Config.project_file_path
+          unless File.exist?(config_path)
+            abort pastel.red("Arquivo .jatai.yml não encontrado. Execute `jatai init` primeiro.")
+          end
+          YAML.safe_load(File.read(config_path), symbolize_names: true)
+        end
+      end
+
+      def app_slug
+        project_config[:app]
+      end
+
+      def require_auth!
+        return if Config.token
+        abort pastel.red("Não autenticado. Execute `jatai login` primeiro.")
+      end
+
+      def success(msg)
+        puts pastel.green(msg)
+      end
+
+      def error(msg)
+        puts pastel.red(msg)
+      end
+
+      def info(msg)
+        puts pastel.cyan(msg)
+      end
+    end
+  end
+end

data/lib/jatai/commands/database.rb

@@ -0,0 +1,75 @@
+require "thor"
+require "tty-prompt"
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Database < Thor
+      namespace :db
+
+      desc "info", "Informações do banco de dados"
+      def info
+        slug = helper.app_slug
+
+        db = helper.api.get("/api/v1/apps/#{slug}/database")
+
+        puts helper.pastel.bold("Banco de dados de #{slug}")
+        puts "  Tier:     #{db["database_tier"] || db["mode"]}"
+        puts "  Host:     #{db["host"]}"
+        puts "  Porta:    #{db["port"]}"
+        puts "  Nome:     #{db["name"]}"
+        puts "  Status:   #{db["status"]}"
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "backups", "Listar backups disponíveis"
+      def backups
+        slug = helper.app_slug
+
+        result = helper.api.get("/api/v1/apps/#{slug}/database/backups")
+        backups_list = result["backups"] || []
+
+        if backups_list.empty?
+          helper.info("Nenhum backup disponível.")
+          return
+        end
+
+        backups_list.each do |b|
+          puts "#{helper.pastel.bold(b["id"])} — #{b["name"]} (#{b["created_at"]})"
+        end
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "backup", "Criar backup do banco de dados"
+      def backup
+        slug = helper.app_slug
+
+        name = "manual-#{Time.now.strftime("%Y%m%d-%H%M%S")}"
+        helper.info("Criando backup do banco de dados...")
+        result = helper.api.post("/api/v1/apps/#{slug}/database/backups", body: { name: name })
+        helper.success("Backup criado: #{result["id"]} (#{name})")
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "restore BACKUP_ID", "Restaurar backup do banco de dados"
+      def restore(backup_id)
+        helper.error("Recurso em desenvolvimento. Restauração de backups ainda não está disponível.")
+      end
+
+      private
+
+      def helper
+        @helper ||= begin
+          h = DatabaseHelper.new
+          h.require_auth!
+          h
+        end
+      end
+    end
+
+    class DatabaseHelper < Base; end
+  end
+end

data/lib/jatai/commands/deploy.rb

@@ -0,0 +1,106 @@
+require "jatai/commands/base"
+require "jatai/source_packer"
+require "tty-spinner"
+
+module Jatai
+  module Commands
+    class Deploy < Base
+      POLL_INTERVAL = 5
+      DEPLOY_TIMEOUT = 1800
+      DEPLOY_MAX_POLLS = 360
+
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+
+        info("Empacotando código...")
+        archive_path = SourcePacker.pack
+        size_kb = File.size(archive_path) / 1024
+
+        spinner = TTY::Spinner.new("#{pastel.cyan("       Enviando #{size_kb}KB...")} :spinner", format: :dots)
+        spinner.auto_spin
+        deploy = api.upload("/api/v1/apps/#{slug}/deploys",
+          file_path: archive_path,
+          params: { branch: options["branch"] || project_config[:branch] || "main" })
+        spinner.success(pastel.green("enviado!"))
+        info("Deploy ##{deploy["id"]} criado.")
+        info("       Na fila...")
+
+        wait_for_deploy_complete(slug, deploy["id"])
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      ensure
+        FileUtils.rm_f(archive_path) if archive_path
+      end
+
+      private
+
+      def wait_for_deploy_complete(slug, deploy_id)
+        ws = connect_websocket
+        started = Time.now
+
+        ws.on_log { |msg| print msg["line"] + "\n" if msg.is_a?(Hash) && msg["line"] }
+        ws.subscribe("DeployLogChannel", deploy_id: deploy_id)
+
+        status = ws.wait_for("DeployStatusChannel",
+          params: { deploy_id: deploy_id },
+          until_status: %w[live failed],
+          timeout: DEPLOY_TIMEOUT)
+
+        elapsed = (Time.now - started).to_i
+        if status == "live"
+          success("\nDeploy concluído com sucesso! (#{elapsed}s)")
+        else
+          error("\nDeploy falhou.")
+        end
+      rescue Jatai::Websocket::CableClient::ConnectionError => e
+        $stderr.puts "\n       [WebSocket indisponível: #{e.message}. Usando polling...]"
+        wait_for_deploy_polling(slug, deploy_id)
+      ensure
+        ws&.disconnect
+      end
+
+      def connect_websocket
+        require "jatai/websocket/cable_client"
+        Jatai::Websocket::CableClient.new.tap(&:connect!)
+      end
+
+      def wait_for_deploy_polling(slug, deploy_id)
+        started = Time.now
+        last_status = nil
+        DEPLOY_MAX_POLLS.times do |i|
+          deploy = api.get("/api/v1/apps/#{slug}/deploys/#{deploy_id}")
+          case deploy["status"]
+          when "live"
+            success("\nDeploy concluído com sucesso! (#{(Time.now - started).to_i}s)")
+            return
+          when "failed"
+            error("\nDeploy falhou.")
+            return
+          end
+          if deploy["status"] != last_status
+            print "\n       #{status_label(deploy["status"])}"
+            last_status = deploy["status"]
+          end
+          print "."
+          show_elapsed(started) if (i % 12).zero? && i > 0
+          sleep(POLL_INTERVAL)
+        rescue Faraday::Error, Errno::ECONNREFUSED, IO::TimeoutError
+          print "!"
+          sleep(POLL_INTERVAL)
+        end
+        error("\nTimeout (#{(Time.now - started).to_i}s). Verifique com: jatai status")
+      end
+
+      def status_label(status)
+        { "queued" => "Na fila...", "building" => "Construindo imagem...",
+          "deploying" => "Deployando..." }[status] || status
+      end
+
+      def show_elapsed(started)
+        elapsed = (Time.now - started).to_i
+        print " (#{elapsed / 60}m#{elapsed % 60}s)"
+      end
+    end
+  end
+end

data/lib/jatai/commands/destroy.rb

@@ -0,0 +1,32 @@
+require "jatai/commands/base"
+require "tty-prompt"
+
+module Jatai
+  module Commands
+    class Destroy < Base
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+
+        prompt = TTY::Prompt.new
+        unless prompt.yes?("Tem certeza que deseja destruir #{slug}? Esta ação é irreversível.")
+          info("Operação cancelada.")
+          return
+        end
+
+        confirmation = prompt.ask("Digite o nome do app para confirmar (#{slug}):")
+        unless confirmation == slug
+          error("Nome não confere. Operação cancelada.")
+          return
+        end
+
+        info("Destruindo #{slug}...")
+        result = api.delete("/api/v1/apps/#{slug}")
+        success("App #{slug} marcado para destruição (status: #{result["status"]}).")
+        info("Os recursos serão removidos em segundo plano.")
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jatai/commands/domains.rb

@@ -0,0 +1,98 @@
+require "thor"
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Domains < Thor
+      namespace :domains
+
+      desc "list", "Listar domínios customizados"
+      def list
+        slug = helper.app_slug
+
+        domains = helper.api.get("/api/v1/apps/#{slug}/domains")
+
+        if domains.nil? || domains.empty?
+          helper.info("Nenhum domínio configurado.")
+          return
+        end
+
+        domains.each do |domain|
+          status_icon = domain["status"] == "active" ? helper.pastel.green("●") : helper.pastel.yellow("○")
+          puts "#{status_icon} #{helper.pastel.bold(domain["hostname"])} (#{domain["status"]})"
+          puts "  Token: #{domain["verification_token"]}" if domain["status"] == "pending"
+        end
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "add HOSTNAME", "Adicionar domínio customizado"
+      def add(hostname)
+        slug = helper.app_slug
+
+        result = helper.api.post("/api/v1/apps/#{slug}/domains", body: { domain: { hostname: hostname } })
+        app = helper.api.get("/api/v1/apps/#{slug}")
+        helper.success("Domínio #{hostname} adicionado.")
+        helper.info("Token de verificação: #{result["verification_token"]}")
+        helper.info("Adicione um registro CNAME apontando para #{app["subdomain"]}.usebrasa.com.br")
+      rescue Api::Client::ValidationError => e
+        helper.error("Erro: #{e.message}")
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "remove HOSTNAME", "Remover domínio customizado"
+      def remove(hostname)
+        slug = helper.app_slug
+
+        domains = helper.api.get("/api/v1/apps/#{slug}/domains")
+        domain = domains&.find { |d| d["hostname"] == hostname }
+
+        unless domain
+          helper.error("Domínio #{hostname} não encontrado.")
+          return
+        end
+
+        helper.api.delete("/api/v1/apps/#{slug}/domains/#{domain["id"]}")
+        helper.success("Domínio #{hostname} removido.")
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "verify HOSTNAME", "Verificar domínio customizado"
+      def verify(hostname)
+        slug = helper.app_slug
+
+        domains = helper.api.get("/api/v1/apps/#{slug}/domains")
+        domain = domains&.find { |d| d["hostname"] == hostname }
+
+        unless domain
+          helper.error("Domínio #{hostname} não encontrado.")
+          return
+        end
+
+        result = helper.api.post("/api/v1/apps/#{slug}/domains/#{domain["id"]}/verify")
+
+        if result["status"] == "active"
+          helper.success("Domínio #{hostname} verificado com sucesso!")
+        else
+          helper.error("Verificação falhou. Certifique-se de que o registro DNS está configurado.")
+        end
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      private
+
+      def helper
+        @helper ||= begin
+          h = DomainsHelper.new
+          h.require_auth!
+          h
+        end
+      end
+    end
+
+    class DomainsHelper < Base; end
+  end
+end