jatai 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bf8aed477b1220c2ffd5b71fc309ac1f407a51404b43603f9ce08ad7f29f78c
-  data.tar.gz: 2514d15c7bcdc3460193c286ff6657b27aae26817524b66121cbc96ccc28a03c
+  metadata.gz: 648533180b943e80129355c3308d594f1867fde7946470361f3897ad3cdd06eb
+  data.tar.gz: 2cfe1d3481ef074b1c1e257f0cd2eea369193a6681694d5d2da6a8e6131f4c42
 SHA512:
-  metadata.gz: 3d6f9195e30feeb5798276c198ffcddcd8ef429bbd65c4bd9444adf50089c0983ee124afe8a8bd72e342b7199248c46477241deb2083f3d7e9caf4438238a963
-  data.tar.gz: a6d364146dd82c0321773da507e2eea74b40b637601c27b7cabe45d5cea9b4f61d7a007125b38d25fd346a20a00862733db5945c6af97dfcff1d9a88b41cd09b
+  metadata.gz: 82d898f647e4109c8842d35d203fd818a170f013f174865ef91e5934a6afc93083e2dd4aa7dd305ef2922d7ab2897c0257f9dbd9fba8c763a021b4707851a7be
+  data.tar.gz: 444b6824a85488f361916f126e34bc68e574c7248bef66d35c51430cdaa9056ad0b18d6880a17ea856d2ef98ca1483f7df71ad991d08729c19630f6b053b99a8

data/lib/jatai/cli.rb

@@ -13,6 +13,7 @@ require "jatai/commands/status"
 require "jatai/commands/destroy"
 require "jatai/commands/domains"
 require "jatai/commands/redis"
+require "jatai/commands/run"
 
 module Jatai
   class CLI < Thor
@@ -41,6 +42,13 @@ module Jatai
       Commands::Deploy.new.execute(options)
     end
 
+    # "run" é palavra reservada do Thor — mapeada p/ run_command.
+    desc "run COMANDO", "Executar comando one-off no app (pod efêmero do release atual)"
+    map "run" => :run_command
+    def run_command(*command_parts)
+      Commands::Run.new.execute(command_parts)
+    end
+
     desc "logs", "Ver logs da aplicação em tempo real"
     option :tail, type: :numeric, default: 100, desc: "Número de linhas"
     def logs

data/lib/jatai/commands/base.rb

@@ -22,8 +22,25 @@ module Jatai
         end
       end
 
+      # SEMPRE slugifica o que veio do arquivo. Isso é o que dá
+      # retrocompatibilidade com os .jatai.yml gerados antes de `app:` passar a
+      # guardar o slug: lá dentro havia o nome de exibição cru ("Alves
+      # Barbearia"), que ia direto para a URL e estourava no URI antes mesmo de
+      # sair a requisição. Slugificar é idempotente, então arquivo novo — que já
+      # traz o slug — atravessa sem alteração.
       def app_slug
-        project_config[:app]
+        raw = project_config[:app]
+        slug = Slug.from(raw)
+        return slug if slug
+
+        abort pastel.red("`app` inválido no .jatai.yml (#{raw.inspect}). " \
+                         "Use letras, números e hífen, ou rode `jatai init` novamente.")
+      end
+
+      # Nome legível. Arquivo novo traz `name:`; no antigo, o próprio `app:` era
+      # o nome de exibição.
+      def app_name
+        project_config[:name] || project_config[:app]
       end
 
       def require_auth!

data/lib/jatai/commands/init.rb

@@ -11,7 +11,8 @@ module Jatai
         "pro" => "Pro — 2GB RAM, réplicas ilimitadas (R$ 69/mês)"
       }.freeze
 
-      REGIONS = { "br-se1" => "São Paulo", "br-ne1" => "Nordeste" }.freeze
+      # Região única por enquanto (Sudeste). Quando houver multi-região, volta a ser um prompt.
+      DEFAULT_REGION = "br-se1".freeze
       STACKS = {
         "rails" => "Rails",
         "node" => "Node.js",
@@ -43,30 +44,48 @@ module Jatai
           stack = prompt.select("Stack:", STACKS.map { |k, v| { name: v, value: k } })
         end
 
-        name = prompt.ask("Nome do app:") { |q| q.required true }
+        name, slug = ask_name_and_slug(prompt)
         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 } })
         # Sites estáticos não têm banco — não pergunta o tier.
         db_tier = stack == "static" ? nil : prompt.select("Banco de dados:", DATABASE_TIERS.map { |k, v| { name: v, value: k } })
         branch = detect_git_branch || "main"
 
+        # `app` é o IDENTIFICADOR (slug) usado nas URLs da API; `name` é o nome de
+        # exibição. Antes um único campo servia aos dois papéis, e um nome com
+        # espaço ("Alves Barbearia") ia direto para a URL e estourava no URI.
         config = {
-          "app" => name,
+          "app" => slug,
+          "name" => name,
           "stack" => stack,
           "preset" => preset,
-          "region" => region,
+          "region" => DEFAULT_REGION,
           "branch" => branch
         }
         config["database_tier"] = db_tier if db_tier
 
         File.write(config_path, YAML.dump(config))
         success("Arquivo .jatai.yml criado com sucesso!")
+        info("Identificador: #{slug}") if slug != name
         info("Branch: #{branch}")
         info("Execute `jatai up` para criar e fazer deploy do app.")
       end
 
       private
 
+      # O nome é livre; o slug sai dele. Repete a pergunta quando nada
+      # aproveitável sobra (nome só de emoji, por exemplo) em vez de gravar um
+      # `app` vazio que quebraria a primeira requisição.
+      def ask_name_and_slug(prompt)
+        loop do
+          name = prompt.ask("Nome do app:") { |q| q.required true }
+          slug = Slug.from(name)
+          return [ name, slug ] if slug
+
+          error("Não consegui gerar um identificador a partir de #{name.inspect}. " \
+                "Use letras ou números no nome.")
+        end
+      end
+
       def detect_stack
         if File.exist?(File.join(Dir.pwd, "Gemfile"))
           gemfile = File.read(File.join(Dir.pwd, "Gemfile"))

data/lib/jatai/commands/run.rb

@@ -0,0 +1,79 @@
+require "jatai/commands/base"
+
+module Jatai
+  module Commands
+    # jatai run "<comando>" — executa um comando one-off num pod efêmero com a
+    # imagem do release atual, streama a saída e retorna o exit code real.
+    class Run < Base
+      RUN_TIMEOUT = 960 # activeDeadlineSeconds (900) + folga
+
+      def execute(command_parts)
+        require_auth!
+        command = Array(command_parts).join(" ").strip
+        return error("Informe o comando: jatai run \"bin/rails runner '...'\"") if command.empty?
+
+        slug = app_slug
+        run = api.post("/api/v1/apps/#{slug}/runs", body: { command: command })
+        info("Run ##{run["id"]} criado — subindo pod efêmero com o release atual...")
+
+        status = follow(run["id"])
+        finish(slug, run["id"], status)
+      rescue Api::Client::ValidationError => e
+        error("Erro: #{e.message}")
+        exit(1)
+      rescue Api::Client::ApiError => e
+        error("Erro: #{e.message}")
+        exit(1)
+      end
+
+      private
+
+      def follow(run_id)
+        ws = connect_websocket
+        ws.on_log { |msg| puts msg["line"] if msg.is_a?(Hash) && msg["line"] }
+        ws.wait_for("AppRunChannel",
+          params: { run_id: run_id },
+          until_status: %w[succeeded failed error],
+          timeout: RUN_TIMEOUT)
+      rescue Jatai::Websocket::CableClient::ConnectionError
+        info("[WebSocket indisponível — aguardando resultado via API...]")
+        poll_until_done(run_id)
+      ensure
+        ws&.disconnect
+      end
+
+      def poll_until_done(run_id)
+        (RUN_TIMEOUT / 5).times do
+          run = api.get("/api/v1/apps/#{app_slug}/runs/#{run_id}")
+          return run["status"] if %w[succeeded failed error].include?(run["status"])
+          sleep(5)
+        end
+        "error"
+      end
+
+      # O socket entrega o status; o exit code vem da API (fonte de verdade).
+      def finish(slug, run_id, status)
+        run = api.get("/api/v1/apps/#{slug}/runs/#{run_id}")
+        exit_code = run["exit_code"]
+
+        case status
+        when "succeeded"
+          success("Concluído (exit 0)")
+          exit(0)
+        when "failed"
+          hint = exit_code == 137 ? " — processo morto (SIGKILL), possivelmente falta de memória (OOM)" : ""
+          error("Comando terminou com exit #{exit_code}#{hint}")
+          exit(exit_code.to_i.clamp(1, 255))
+        else
+          error("Run falhou na infraestrutura. Tente novamente ou verifique com: jatai status")
+          exit(1)
+        end
+      end
+
+      def connect_websocket
+        require "jatai/websocket/cable_client"
+        Jatai::Websocket::CableClient.new.tap(&:connect!)
+      end
+    end
+  end
+end

data/lib/jatai/commands/up.rb

@@ -46,14 +46,36 @@ module Jatai
 
       private
 
+      # O slug do .jatai.yml é só o PALPITE: o servidor pode ter desambiguado
+      # com sufixo (alves-barbearia-1) quando o nome já existia, e a partir daí
+      # o arquivo apontaria para sempre para um app que não é o do cliente.
+      # Depois de criar, grava de volta o slug que o servidor devolveu — daí em
+      # diante o arquivo carrega a verdade, não a dedução.
       def find_or_create_app(config)
-        existing = api.get("/api/v1/apps/#{config[:app]}")
+        existing = api.get("/api/v1/apps/#{app_slug}")
         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)
+        info("Criando app #{app_name}...")
+        created = create_app(config)
+        persist_server_slug(created["slug"])
+        created
+      end
+
+      def persist_server_slug(server_slug)
+        return if server_slug.nil? || server_slug == project_config[:app]
+
+        path = Config.project_file_path
+        raw = YAML.safe_load(File.read(path))
+        raw["name"] ||= raw["app"] # arquivo antigo: `app` guardava o nome
+        raw["app"] = server_slug
+        File.write(path, YAML.dump(raw))
+        info("Identificador do app no .jatai.yml: #{server_slug}")
+      rescue StandardError => e
+        # Não derruba o deploy: o app foi criado e o deploy segue. Só o arquivo
+        # ficou desatualizado, e o próximo comando cai no palpite de novo.
+        warn(pastel.yellow("       Não foi possível gravar o slug no .jatai.yml: #{e.message}"))
       end
 
       def trigger_provision(slug)
@@ -70,7 +92,7 @@ module Jatai
 
       def create_app(config)
         app_params = {
-          name: config[:app], stack: config[:stack], preset: config[:preset],
+          name: app_name, 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]

data/lib/jatai/slug.rb

@@ -0,0 +1,40 @@
+module Jatai
+  # Converte texto livre no identificador que o servidor usa na URL.
+  #
+  # O servidor gera o slug com `name.parameterize` (ActiveSupport) e o valida
+  # com /\A[a-z0-9]([a-z0-9\-]*[a-z0-9])?\z/. A CLI não depende de
+  # ActiveSupport — carregá-la inteira por uma função encareceria o boot — então
+  # a transliteração é feita à mão para o conjunto que os clientes de fato usam
+  # (português). Caracteres fora dessa tabela são descartados, e é por isso que
+  # esta conversão é só o PALPITE da primeira requisição: quem manda no slug é o
+  # servidor, e o `jatai up` grava de volta no .jatai.yml o slug que ele retorna.
+  #
+  # Idempotente: aplicar sobre um slug válido devolve o mesmo slug. É o que dá
+  # retrocompatibilidade com os .jatai.yml antigos, em que `app:` guardava o
+  # nome de exibição — "Alves Barbearia" vira "alves-barbearia", que é
+  # exatamente o slug que o servidor gerou na criação daquele app.
+  module Slug
+    TRANSLITERATIONS = {
+      "á" => "a", "à" => "a", "â" => "a", "ã" => "a", "ä" => "a", "å" => "a",
+      "é" => "e", "è" => "e", "ê" => "e", "ë" => "e",
+      "í" => "i", "ì" => "i", "î" => "i", "ï" => "i",
+      "ó" => "o", "ò" => "o", "ô" => "o", "õ" => "o", "ö" => "o",
+      "ú" => "u", "ù" => "u", "û" => "u", "ü" => "u",
+      "ç" => "c", "ñ" => "n", "ý" => "y"
+    }.freeze
+
+    module_function
+
+    # nil quando não sobra nada utilizável — quem chama decide o que dizer ao
+    # usuário. Devolver "" mandaria uma URL vazia para a API.
+    def from(text)
+      return nil if text.nil?
+
+      slug = text.to_s.downcase
+      slug = slug.gsub(/[^a-z0-9\-]/) { |char| TRANSLITERATIONS.fetch(char, "-") }
+      slug = slug.gsub(/-+/, "-").gsub(/\A-|-\z/, "")
+
+      slug.empty? ? nil : slug
+    end
+  end
+end

data/lib/jatai/version.rb

@@ -1,3 +1,3 @@
 module Jatai
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
 end

data/lib/jatai.rb

@@ -1,5 +1,6 @@
 require "jatai/version"
 require "jatai/config"
+require "jatai/slug"
 require "jatai/api/client"
 require "jatai/cli"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jatai
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Jataí Cloud
@@ -176,10 +176,12 @@ files:
 - lib/jatai/commands/logs_export.rb
 - lib/jatai/commands/logs_search.rb
 - lib/jatai/commands/redis.rb
+- lib/jatai/commands/run.rb
 - lib/jatai/commands/scale.rb
 - lib/jatai/commands/status.rb
 - lib/jatai/commands/up.rb
 - lib/jatai/config.rb
+- lib/jatai/slug.rb
 - lib/jatai/source_packer.rb
 - lib/jatai/version.rb
 - lib/jatai/websocket/cable_client.rb