jatai 1.0.0

data/lib/jatai/commands/env.rb

@@ -0,0 +1,66 @@
+require "thor"
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Env < Thor
+      namespace :env
+
+      desc "list", "Listar variáveis de ambiente"
+      def list
+        helper = EnvHelper.new
+        helper.require_auth!
+        slug = helper.app_slug
+
+        vars = helper.api.get("/api/v1/apps/#{slug}/env")
+
+        if vars.nil? || vars.empty?
+          helper.info("Nenhuma variável de ambiente configurada.")
+          return
+        end
+
+        vars.each do |key, value|
+          puts "#{helper.pastel.bold(key)}=#{value}"
+        end
+      rescue Api::Client::ApiError => e
+        EnvHelper.new.error("Erro: #{e.message}")
+      end
+
+      desc "set KEY=VALUE [KEY=VALUE...]", "Definir variáveis de ambiente"
+      def set(*pairs)
+        helper = EnvHelper.new
+        helper.require_auth!
+        slug = helper.app_slug
+
+        env_vars = {}
+        pairs.each do |pair|
+          key, value = pair.split("=", 2)
+          if key.nil? || key.empty? || value.nil?
+            helper.error("Formato inválido: #{pair}. Use KEY=VALUE.")
+            return
+          end
+          env_vars[key] = value
+        end
+
+        helper.api.put("/api/v1/apps/#{slug}/env", body: { env: env_vars })
+        helper.success("Variáveis de ambiente atualizadas.")
+      rescue Api::Client::ApiError => e
+        EnvHelper.new.error("Erro: #{e.message}")
+      end
+
+      desc "unset KEY [KEY...]", "Remover variáveis de ambiente"
+      def unset(*keys)
+        helper = EnvHelper.new
+        helper.require_auth!
+        slug = helper.app_slug
+
+        helper.api.delete("/api/v1/apps/#{slug}/env/#{keys.join(",")}")
+        helper.success("Variáveis removidas: #{keys.join(", ")}")
+      rescue Api::Client::ApiError => e
+        EnvHelper.new.error("Erro: #{e.message}")
+      end
+    end
+
+    class EnvHelper < Base; end
+  end
+end

data/lib/jatai/commands/init.rb

@@ -0,0 +1,83 @@
+require "jatai/commands/base"
+require "tty-prompt"
+require "yaml"
+
+module Jatai
+  module Commands
+    class Init < Base
+      PRESETS = {
+        "micro" => "Micro — 256MB RAM, 1 réplica (Grátis)",
+        "hobby" => "Hobby — 1GB RAM, réplicas ilimitadas (R$ 19/mês)",
+        "pro" => "Pro — 2GB RAM, réplicas ilimitadas (R$ 69/mês)"
+      }.freeze
+
+      REGIONS = { "br-se1" => "São Paulo", "br-ne1" => "Nordeste" }.freeze
+      STACKS = { "rails" => "Rails", "node" => "Node.js", "docker" => "Docker (custom Dockerfile)" }.freeze
+      DATABASE_TIERS = {
+        "mini" => "Mini — 512MB, 20 conexões (Grátis)",
+        "essencial" => "Essencial — 1GB, 50 conexões (R$ 19/mês)",
+        "padrao" => "Padrão — 5GB, 100 conexões (R$ 49/mês)"
+      }.freeze
+
+      def execute(options = {})
+        prompt = TTY::Prompt.new
+        config_path = File.join(Dir.pwd, Config::PROJECT_FILE)
+
+        if File.exist?(config_path)
+          return unless prompt.yes?("Arquivo .jatai.yml já existe. Sobrescrever?")
+        end
+
+        stack = detect_stack
+        if stack
+          info("Stack detectado: #{STACKS[stack]}")
+          unless prompt.yes?("Confirmar stack #{STACKS[stack]}?")
+            stack = prompt.select("Stack:", STACKS.map { |k, v| { name: v, value: k } })
+          end
+        else
+          info("Não foi possível detectar o stack automaticamente.")
+          stack = prompt.select("Stack:", STACKS.map { |k, v| { name: v, value: k } })
+        end
+
+        name = prompt.ask("Nome do app:") { |q| q.required true }
+        preset = prompt.select("Preset:", PRESETS.map { |k, v| { name: v, value: k } })
+        region = prompt.select("Região:", REGIONS.map { |k, v| { name: "#{v} (#{k})", value: k } })
+        db_tier = prompt.select("Banco de dados:", DATABASE_TIERS.map { |k, v| { name: v, value: k } })
+        branch = detect_git_branch || "main"
+
+        config = {
+          "app" => name,
+          "stack" => stack,
+          "preset" => preset,
+          "region" => region,
+          "branch" => branch,
+          "database_tier" => db_tier
+        }
+
+        File.write(config_path, YAML.dump(config))
+        success("Arquivo .jatai.yml criado com sucesso!")
+        info("Branch: #{branch}")
+        info("Execute `jatai up` para criar e fazer deploy do app.")
+      end
+
+      private
+
+      def detect_stack
+        if File.exist?(File.join(Dir.pwd, "Gemfile"))
+          gemfile = File.read(File.join(Dir.pwd, "Gemfile"))
+          return "rails" if gemfile.include?("rails")
+        end
+
+        return "node" if File.exist?(File.join(Dir.pwd, "package.json"))
+
+        return "docker" if File.exist?(File.join(Dir.pwd, "Dockerfile"))
+
+        nil
+      end
+
+      def detect_git_branch
+        branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        branch.empty? ? nil : branch
+      end
+    end
+  end
+end

data/lib/jatai/commands/login.rb

@@ -0,0 +1,25 @@
+require "jatai/commands/base"
+require "tty-prompt"
+
+module Jatai
+  module Commands
+    class Login < Base
+      def execute(options = {})
+        prompt = TTY::Prompt.new
+
+        email = prompt.ask("Email:")
+        password = prompt.mask("Senha:")
+
+        client = Api::Client.new(token: nil)
+        response = client.post("/users/tokens/sign_in", body: { email: email, password: password })
+
+        Config.save_token(response["token"])
+        success("Login realizado com sucesso!")
+      rescue Api::Client::AuthenticationError
+        error("Credenciais inválidas. Verifique email e senha.")
+      rescue Api::Client::ApiError => e
+        error("Erro ao fazer login: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jatai/commands/logs.rb

@@ -0,0 +1,40 @@
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Logs < Base
+      DEFAULT_TAIL = 100
+
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+        tail = options.fetch("tail", DEFAULT_TAIL).to_s
+
+        logs = api.get("/api/v1/apps/#{slug}/logs", params: { tail: tail })
+
+        if logs.nil? || logs.empty?
+          info("Nenhum log disponível.")
+          return
+        end
+
+        logs.each do |entry|
+          timestamp = entry["timestamp"]
+          source = entry["source"]
+          level = entry["level"]
+          message = entry["message"]
+
+          level_str = case level
+          when "error" then pastel.red(level)
+          when "warn" then pastel.yellow(level)
+          when "info" then pastel.green(level)
+          else pastel.dim(level || "log")
+          end
+
+          puts "#{pastel.dim(timestamp)} #{pastel.cyan(source)} [#{level_str}] #{message}"
+        end
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jatai/commands/logs_export.rb

@@ -0,0 +1,33 @@
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class LogsExport < Base
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+
+        format = options.fetch("format", "json")
+        params = { export_format: format }
+        params[:since] = options["since"] if options["since"]
+        params[:until] = options["until"] if options["until"]
+        params[:level] = options["level"] if options["level"]
+
+        result = api.get("/api/v1/apps/#{slug}/logs/export", params: params)
+
+        case result
+        when Array
+          puts JSON.pretty_generate(result)
+        when Hash
+          puts JSON.pretty_generate(result)
+        when String
+          puts result
+        else
+          puts result
+        end
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jatai/commands/logs_search.rb

@@ -0,0 +1,47 @@
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class LogsSearch < Base
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+        query = options["query"]
+
+        unless query
+          info("Uso: jatai logs:search <query> [--level error] [--since 1h]")
+          return
+        end
+
+        params = { q: query, limit: options.fetch("limit", "100") }
+        params[:level] = options["level"] if options["level"]
+        params[:source] = options["source"] if options["source"]
+        params[:since] = options["since"] if options["since"]
+
+        results = api.get("/api/v1/apps/#{slug}/logs/search", params: params)
+
+        if results.nil? || results.empty?
+          info("Nenhum resultado encontrado.")
+          return
+        end
+
+        results.each do |entry|
+          puts "#{pastel.dim(entry["timestamp"])} #{pastel.cyan(entry["source"])} [#{colorize_level(entry["level"])}] #{entry["message"]}"
+        end
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+
+      private
+
+      def colorize_level(level)
+        case level
+        when "error" then pastel.red(level)
+        when "warn" then pastel.yellow(level)
+        when "info" then pastel.green(level)
+        else pastel.dim(level)
+        end
+      end
+    end
+  end
+end

data/lib/jatai/commands/redis.rb

@@ -0,0 +1,79 @@
+require "thor"
+require "tty-prompt"
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Redis < Thor
+      namespace :redis
+
+      MEMORY_TO_PLAN = {
+        256 => "starter",
+        512 => "pro",
+        1024 => "business"
+      }.freeze
+
+      desc "status", "Ver status do Redis"
+      def status
+        slug = helper.app_slug
+
+        addon = helper.api.get("/api/v1/apps/#{slug}/addons/cache")
+
+        puts helper.pastel.bold("Redis de #{slug}")
+        puts "  Status:   #{addon["status"]}"
+        puts "  Plano:    #{addon["plan"]}"
+        puts "  Memória:  #{addon.dig("config", "memory_mb")}MB"
+        puts "  Custo:    R$ #{addon["monthly_cost_brl"]}/mês"
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "enable", "Habilitar Redis para o app"
+      option :memory, type: :numeric, default: 256, desc: "Memória em MB (256, 512, 1024)"
+      def enable
+        slug = helper.app_slug
+
+        plan = MEMORY_TO_PLAN[options[:memory]]
+        unless plan
+          helper.error("Memória inválida. Use: 256, 512 ou 1024")
+          return
+        end
+
+        helper.info("Habilitando Redis com #{options[:memory]}MB (plano #{plan})...")
+        result = helper.api.post("/api/v1/apps/#{slug}/addons", body: { addon: { slug: "cache", plan: plan } })
+        helper.success("Redis habilitado! Status: #{result["status"]}")
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      desc "disable", "Remover Redis do app"
+      def disable
+        slug = helper.app_slug
+
+        prompt = TTY::Prompt.new
+        unless prompt.yes?("Remover Redis? Todos os dados em cache serão perdidos.")
+          helper.info("Operação cancelada.")
+          return
+        end
+
+        helper.info("Removendo Redis...")
+        helper.api.delete("/api/v1/apps/#{slug}/addons/cache")
+        helper.success("Redis removido com sucesso!")
+      rescue Api::Client::ApiError => e
+        helper.error("Erro: #{e.message}")
+      end
+
+      private
+
+      def helper
+        @helper ||= begin
+          h = RedisHelper.new
+          h.require_auth!
+          h
+        end
+      end
+    end
+
+    class RedisHelper < Base; end
+  end
+end

data/lib/jatai/commands/scale.rb

@@ -0,0 +1,39 @@
+require "jatai/commands/base"
+require "tty-prompt"
+
+module Jatai
+  module Commands
+    class Scale < Base
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+
+        body = {}
+        body[:replicas] = options["replicas"].to_i if options["replicas"]
+        body[:preset] = options["preset"] if options["preset"]
+
+        if body.empty?
+          error("Informe ao menos --replicas ou --preset. Ex: jatai scale --replicas 3")
+          return
+        end
+
+        estimate = api.post("/api/v1/apps/#{slug}/scale/estimate", body: body)
+        info("Preset: #{estimate["preset"]}")
+        info("Réplicas: #{estimate["replicas"]}") if estimate["replicas"]
+        info("CPU: #{estimate["cpu_limit"]}  |  RAM: #{estimate["memory_limit"]}") if estimate["cpu_limit"]
+        info("Custo estimado: R$ #{estimate["monthly_cost"]}/mês")
+
+        prompt = TTY::Prompt.new
+        unless prompt.yes?("Confirmar escalonamento?")
+          info("Escalonamento cancelado.")
+          return
+        end
+
+        api.put("/api/v1/apps/#{slug}/scale", body: body)
+        success("Escalonamento aplicado com sucesso!")
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jatai/commands/status.rb

@@ -0,0 +1,53 @@
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    class Status < Base
+      def execute(options = {})
+        require_auth!
+        slug = app_slug
+
+        app = api.get("/api/v1/apps/#{slug}")
+
+        puts pastel.bold("App: #{app["name"]}")
+        puts "  Slug:    #{app["slug"]}"
+        puts "  Stack:   #{app["stack"]}"
+        puts "  Status:  #{colorize_status(app["status"])}"
+        puts "  Região:  #{app["region"]}"
+        puts "  Preset:  #{app["preset"]}"
+        puts "  DB:      #{app["database_tier"]}"
+        subdomain = app["subdomain"] || app["slug"]
+        puts "  URL:     https://#{subdomain}.usebrasa.com.br"
+
+        if app["last_deploy"]
+          deploy = app["last_deploy"]
+          puts ""
+          puts pastel.bold("Último deploy:")
+          puts "  ID:      #{deploy["id"]}"
+          puts "  Status:  #{colorize_status(deploy["status"])}"
+          puts "  Commit:  #{deploy["commit_sha"]}" if deploy["commit_sha"]
+          puts "  Data:    #{deploy["created_at"]}"
+        end
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+
+      private
+
+      def colorize_status(status)
+        case status
+        when "active", "live"
+          pastel.green(status)
+        when "sleeping"
+          pastel.blue(status)
+        when "failed", "error"
+          pastel.red(status)
+        when "building", "deploying", "provisioning"
+          pastel.yellow(status)
+        else
+          status
+        end
+      end
+    end
+  end
+end

data/lib/jatai/commands/up.rb

@@ -0,0 +1,220 @@
+require "jatai/commands/base"
+require "jatai/source_packer"
+require "tty-spinner"
+
+module Jatai
+  module Commands
+    class Up < Base
+      POLL_INTERVAL = 5
+      PROVISION_TIMEOUT = 1200
+      DEPLOY_TIMEOUT = 1800
+      PROVISION_MAX_POLLS = 240
+      DEPLOY_MAX_POLLS = 360
+
+      def execute(options = {})
+        require_auth!
+        config = project_config
+
+        @app = find_or_create_app(config)
+        slug = @app["slug"]
+
+        if %w[active sleeping].include?(@app["status"])
+          info("Iniciando deploy...")
+        else
+          info("Provisionando infraestrutura...")
+          trigger_provision(slug) if %w[pending error].include?(@app["status"])
+          unless wait_for_provisioning(@app["id"], slug)
+            return
+          end
+          success("Infraestrutura provisionada!")
+          info("Iniciando primeiro deploy...")
+        end
+
+        deploy = trigger_deploy(slug)
+        info("       Na fila...")
+
+        if wait_for_deploy_complete(slug, deploy["id"])
+          subdomain = @app["subdomain"] || slug
+          success("Deploy concluído! App disponível em https://#{subdomain}.usebrasa.com.br")
+        end
+      rescue Api::Client::ValidationError => e
+        error("Erro ao criar app: #{e.message}")
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+      end
+
+      private
+
+      def find_or_create_app(config)
+        existing = api.get("/api/v1/apps/#{config[:app]}")
+        info("App #{existing["slug"]} encontrado (#{existing["status"]}).")
+        ensure_repo_url(existing["slug"])
+        existing
+      rescue Api::Client::NotFoundError
+        info("Criando app #{config[:app]}...")
+        create_app(config)
+      end
+
+      def trigger_provision(slug)
+        api.post("/api/v1/apps/#{slug}/provision")
+      rescue Api::Client::ApiError
+      end
+
+      def ensure_repo_url(slug)
+        repo = detect_git_remote
+        return unless repo
+        api.patch("/api/v1/apps/#{slug}", body: { app: { repo_url: repo } })
+      rescue Api::Client::ApiError
+      end
+
+      def create_app(config)
+        app_params = {
+          name: config[:app], stack: config[:stack], preset: config[:preset],
+          region: config[:region], repo_url: detect_git_remote, repo_branch: config[:branch]
+        }
+        app_params[:database_tier] = config[:database_tier] if config[:database_tier]
+        app_params[:release_command] = config.dig(:release, :command) if config.dig(:release, :command)
+        api.post("/api/v1/apps", body: { app: app_params })
+      end
+
+      def trigger_deploy(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
+        result = api.upload("/api/v1/apps/#{slug}/deploys", file_path: archive_path,
+                            params: { branch: project_config[:branch] || "main" })
+        spinner.success(pastel.green("enviado!"))
+        result
+      ensure
+        FileUtils.rm_f(archive_path) if archive_path
+      end
+
+      def detect_git_remote
+        remote = `git remote get-url origin 2>/dev/null`.strip
+        remote.empty? ? nil : remote
+      end
+
+      # ── WebSocket methods ──
+
+      def wait_for_provisioning(app_id, slug)
+        ws = connect_websocket
+        status = ws.wait_for("ProvisionStatusChannel",
+          params: { app_id: app_id },
+          until_status: %w[active error],
+          timeout: PROVISION_TIMEOUT)
+
+        if status == "active"
+          true
+        else
+          error("\nErro no provisionamento.")
+          false
+        end
+      rescue Jatai::Websocket::CableClient::ConnectionError => e
+        warn_fallback(e)
+        wait_for_provisioning_polling(slug)
+      ensure
+        ws&.disconnect
+      end
+
+      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)
+
+        if status == "live"
+          true
+        else
+          error("\nDeploy falhou.")
+          false
+        end
+      rescue Jatai::Websocket::CableClient::ConnectionError => e
+        warn_fallback(e)
+        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 warn_fallback(err)
+        $stderr.puts "\n       [WebSocket indisponível: #{err.message}. Usando polling...]"
+      end
+
+      # ── Fallback polling ──
+
+      def wait_for_provisioning_polling(slug)
+        started = Time.now
+        last_status = nil
+        PROVISION_MAX_POLLS.times do |i|
+          app = api.get("/api/v1/apps/#{slug}")
+          return true if app["status"] == "active"
+          if app["status"] == "error"
+            error("\nErro no provisionamento.")
+            return false
+          end
+          if app["status"] != last_status
+            print "\n       #{status_label(app["status"])}"
+            last_status = app["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")
+        false
+      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}")
+          return true if deploy["status"] == "live"
+          if deploy["status"] == "failed"
+            error("\nDeploy falhou.")
+            return false
+          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")
+        false
+      end
+
+      def status_label(status)
+        { "pending" => "Aguardando...", "provisioning" => "Provisionando...",
+          "queued" => "Na fila...", "building" => "Construindo imagem...",
+          "deploying" => "Implantando..." }[status] || status
+      end
+
+      def show_elapsed(started)
+        elapsed = (Time.now - started).to_i
+        print " (#{elapsed / 60}m#{elapsed % 60}s)"
+      end
+    end
+  end
+end