captive-cli 1.0.0

data/lib/captive/dashboard_client.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "time"
+require_relative "errors"
+
+module Captive
+  class DashboardClient
+    DASHBOARD_URL = "https://dashboard.captive.dev"
+    TOKEN_PATH    = File.expand_path("~/.config/captive/token")
+
+    PAGE_SIZE = 500
+
+    def logs(app, start_at: nil, end_at: nil, limit: nil)
+      token = read_token
+
+      if start_at || end_at
+        fetch_all(app, token, start_at:, end_at:)
+      else
+        uri      = build_uri(app, limit: limit || PAGE_SIZE)
+        response = get(uri, token)
+        page, _  = extract_page(handle_response(response))
+        page
+      end
+    end
+
+    # Signale au dashboard un accès ouvert sur l'app. L'acteur n'est pas transmis : le
+    # dashboard le dérive du token, ce qui le rend infalsifiable côté client.
+    def record_activity(app, kind:, command: nil, session: nil)
+      uri  = URI.parse("#{DASHBOARD_URL}/api/apps/#{URI.encode_uri_component(app)}/activity")
+      body = { kind: kind }
+      body[:command] = command if command
+      body[:session] = session if session
+
+      post(uri, read_token, body)
+    end
+
+    private
+
+    # Pagine en remontant depuis end_at vers start_at (direction backward côté Loki).
+    # Chaque page utilise le ts du log le plus ancien comme prochain curseur `before`.
+    def fetch_all(app, token, start_at:, end_at:)
+      pages  = []
+      cursor = end_at
+
+      loop do
+        uri      = build_uri(app, start_at:, before: cursor, limit: PAGE_SIZE)
+        response = get(uri, token)
+        page, has_more = extract_page(handle_response(response))
+
+        break if page.empty?
+
+        pages << page
+        break unless has_more
+
+        # page est trié ASC — le premier élément est le plus ancien
+        cursor = Time.parse(page.first["ts"]) - Rational(1, 1000)
+        break if start_at && cursor <= start_at
+      end
+
+      pages.reverse.flatten(1)
+    end
+
+    # Accepte l'ancien format (Array) et le nouveau ({lines, has_more}).
+    # Pour l'ancien format, on continue tant qu'on reçoit des résultats :
+    # le curseur (cursor <= start_at) est le seul stop fiable.
+    def extract_page(data)
+      if data.is_a?(Hash)
+        [ data.fetch("lines", []), data.fetch("has_more", false) ]
+      else
+        [ data, !data.empty? ]
+      end
+    end
+
+    def read_token
+      raise NotAuthenticatedError, "Pas de session active. Lance : captive login" unless File.exist?(TOKEN_PATH)
+
+      File.read(TOKEN_PATH).strip
+    end
+
+    def build_uri(app, start_at: nil, end_at: nil, before: nil, limit:)
+      params = { limit: }
+      params[:start_at] = start_at.utc.iso8601(3) if start_at
+      params[:end_at]   = end_at.utc.iso8601(3)   if end_at
+      params[:before]   = before.utc.iso8601(3)   if before
+      uri       = URI.parse("#{DASHBOARD_URL}/api/apps/#{URI.encode_uri_component(app)}/logs")
+      uri.query = URI.encode_www_form(params)
+      uri
+    end
+
+    def get(uri, token)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                      open_timeout: 5, read_timeout: 30) do |http|
+        http.get(uri.request_uri, "Authorization" => "Bearer #{token}", "Accept" => "application/json")
+      end
+    end
+
+    # Timeouts courts : une console ne doit pas attendre un dashboard qui ne répond pas.
+    def post(uri, token, body)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                      open_timeout: 2, read_timeout: 5) do |http|
+        http.post(uri.request_uri, JSON.generate(body),
+                  "Authorization" => "Bearer #{token}",
+                  "Accept"        => "application/json",
+                  "Content-Type"  => "application/json")
+      end
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200 then JSON.parse(response.body)
+      when 401 then raise AuthError, "Token invalide ou expiré. Lance : captive login"
+      else raise "Erreur dashboard (HTTP #{response.code})"
+      end
+    end
+  end
+end

data/lib/captive/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Captive
+  class NoPodFound < StandardError; end
+  class UnknownAppType < StandardError; end
+  class PollTimeout < StandardError; end
+  class ImageYamlNotFound < StandardError; end
+  class WorkflowDispatchNotConfigured < StandardError; end
+  class RestoreError < StandardError; end
+  class DumpError < StandardError; end
+  class ExecError < StandardError; end
+  class AuthError < StandardError; end
+  class NotAuthenticatedError < StandardError; end
+  class NoTtyError < StandardError; end
+  class PlatformRootNotFound < StandardError; end
+end

data/lib/captive/flux.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Captive
+  class Flux
+    def suspend_kustomization(name)
+      Open3.capture3("flux", "suspend", "kustomization", name)
+    end
+
+    def resume_kustomization(name)
+      Open3.capture3("flux", "resume", "kustomization", name)
+    end
+  end
+end

data/lib/captive/gh_cli.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "errors"
+
+module Captive
+  class GhCLI
+    def trigger_workflow(repo, workflow: "ci.yml", ref: "main", fields: {})
+      field_args = fields.flat_map { |k, v| [ "--field", "#{k}=#{v}" ] }
+      run("workflow", "run", workflow, "--repo", repo, "--ref", ref, *field_args)
+    rescue RuntimeError => e
+      raise WorkflowDispatchNotConfigured,
+        "Le workflow '#{workflow}' de '#{repo}' n'a pas de trigger workflow_dispatch.\n" \
+        "  Regénère le ci.yml : captive apps launch <app> dans le repo de l'app." \
+        if e.message.include?("workflow_dispatch")
+      raise
+    end
+
+    def workflow_exists?(repo)
+      %w[deploy.yml ci.yml].any? do |file|
+        run("api", "/repos/#{repo}/contents/.github/workflows/#{file}") && true
+      rescue RuntimeError
+        false
+      end
+    end
+
+    def latest_run_status(repo)
+      output = run("run", "list", "--repo", repo, "--limit", "1",
+                   "--json", "status,conclusion", "--jq", ".[0]")
+      data = JSON.parse(output)
+      return :success    if data["status"] == "completed" && data["conclusion"] == "success"
+      return :failure    if data["status"] == "completed"
+
+      :in_progress
+    end
+
+    def image_exists?(repo, tag)
+      output = run("api", "/repos/#{repo}/packages/container/#{repo.split("/").last}/versions",
+                   "--jq", ".[].metadata.container.tags[]")
+      output.split("\n").include?(tag)
+    rescue RuntimeError => e
+      return false if e.message.include?("404") || e.message.include?("Not Found")
+
+      raise
+    end
+
+    def app_installed?(repo)
+      run("api", "repos/#{repo}/installation")
+      true
+    rescue RuntimeError
+      false
+    end
+
+    def detect_type(repo)
+      data = JSON.parse(run("api", "repos/#{repo}"))
+      case data["language"]
+      when "Ruby"                     then "rails-app"
+      when "JavaScript", "TypeScript" then "node-app"
+      else raise UnknownAppType, "language non supportée : #{data["language"]}"
+      end
+    end
+
+    PLATFORM_REPO = "captive-studio/captive-platform"
+
+    def dispatch_build(repo)
+      repo_name = repo.split("/").last.downcase
+      sha = run("api", "repos/#{repo}/git/ref/heads/main", "--jq", ".object.sha").strip
+      body = JSON.generate(
+        event_type: "build-app",
+        client_payload: { repo: repo, repo_name: repo_name, sha: sha, ref: "refs/heads/main" }
+      )
+      run_with_input("api", "repos/#{PLATFORM_REPO}/dispatches", "-X", "POST", "--input", "-",
+                     input: body)
+    end
+
+    def run(*args, input: nil)
+      opts = input ? { stdin_data: input } : {}
+      out, err, status = Open3.capture3("gh", *args, **opts)
+      raise "gh #{args.join(" ")} failed: #{err}" unless status.success?
+
+      out
+    end
+
+    def run_with_input(*args, input:)
+      run(*args, input: input)
+    end
+  end
+end

data/lib/captive/github_device_flow.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "http_client"
+
+module Captive
+  class GithubDeviceFlow
+    CLIENT_ID = "Iv23liHr9n6eK4XhwtnP"
+
+    def initialize(http: HttpClient.new)
+      @http = http
+    end
+
+    RETRIABLE_ERRORS = %w[authorization_pending slow_down].freeze
+    DeviceFlowError  = Class.new(StandardError)
+
+    def poll_token(device_code:, interval:)
+      loop do
+        sleep(interval)
+        data = @http.post("https://github.com/login/oauth/access_token",
+                          client_id: CLIENT_ID, device_code: device_code,
+                          grant_type: "urn:ietf:params:oauth:grant-type:device_code")
+        return data["access_token"] if data["access_token"]
+        raise DeviceFlowError, data["error"] unless RETRIABLE_ERRORS.include?(data["error"])
+      end
+    end
+
+    def request_device_code
+      data = @http.post("https://github.com/login/device/code", client_id: CLIENT_ID)
+      raise DeviceFlowError, "Erreur GitHub : #{data.inspect}" unless data["user_code"]
+
+      {
+        device_code:      data["device_code"],
+        user_code:        data["user_code"],
+        verification_uri: data["verification_uri"],
+        interval:         data["interval"],
+      }
+    end
+  end
+end

data/lib/captive/http_client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Captive
+  class HttpClient
+    def post(url, params)
+      request(url) do |http, uri|
+        http.post(uri.request_uri, URI.encode_www_form(params),
+                  "Accept"       => "application/json",
+                  "Content-Type" => "application/x-www-form-urlencoded")
+      end
+    end
+
+    def get(url, headers = {})
+      request(url) { |http, uri| http.get(uri.request_uri, { "Accept" => "application/json" }.merge(headers)) }
+    end
+
+    private
+
+    def request(url, &block)
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                      open_timeout: 2, read_timeout: 2) do |http|
+        JSON.parse(block.call(http, uri).body)
+      end
+    end
+  end
+end

data/lib/captive/kubectl.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "open3"
+require_relative "errors"
+require_relative "log_noise_filter"
+require_relative "one_off_spec"
+require_relative "presenter/log_line"
+
+module Captive
+  class Kubectl
+    EXIT_SUCCESS = 0
+    EXIT_FAILURE = 1
+    TERMINAL_PHASES = %w[Succeeded Failed].freeze
+
+    # Rôle admin non-superuser sous lequel tourne le SQL utilisateur, sur le
+    # modèle du rôle `postgres` de Supabase hébergé et du `neon_superuser` de
+    # Neon. Les apps sans backend Supabase n'ont que le rôle propriétaire `app`.
+    ADMIN_ROLE = "app_admin"
+    ADMIN_SECRET = "supabase-app-admin"
+    OWNER_ROLE = "app"
+
+    def initialize(kubeconfig: nil)
+      @kubeconfig = kubeconfig
+    end
+
+    def get_pod(namespace, app)
+      name, = pod_info(namespace, app)
+      raise NoPodFound, "aucun pod Running pour '#{app}' dans '#{namespace}'" if name.nil? || name.empty?
+
+      name
+    end
+
+    def get_deployment_json(namespace, name)
+      JSON.parse(run("get", "deployment", name, "-n", namespace, "-o", "json"))
+    end
+
+    def create_from_resource(resource)
+      json = JSON.generate(resource)
+      out, err, status = Open3.capture3(
+        "kubectl", *kubeconfig_args, "create", "-f", "-", "-o", "jsonpath={.metadata.name}",
+        stdin_data: json
+      )
+      raise AuthError, "Votre session a expiré. Reconnectez-vous avec : captive login" if err.include?("Unauthorized")
+      raise "kubectl create failed: #{err}" unless status.success?
+
+      out.strip
+    end
+
+    def wait_pod_ready(namespace, pod, timeout: "120s")
+      run("wait", "--for=condition=Ready", "pod/#{pod}", "-n", namespace, "--timeout=#{timeout}")
+    end
+
+    def wait_job_complete(namespace, job, timeout: "3600s")
+      run("wait", "--for=condition=complete", "job/#{job}", "-n", namespace, "--timeout=#{timeout}")
+    end
+
+    def attach(namespace, pod)
+      run_interactive("attach", "-n", namespace, "-it", pod, "-c", OneOffSpec::CONTAINER_NAME)
+    end
+
+    def delete_pod(namespace, pod)
+      run("delete", "pod", pod, "-n", namespace, "--ignore-not-found=true", "--wait=false")
+    end
+
+    # Attend que le pod atteigne une phase terminale. Sert à distinguer une
+    # session console sortie proprement (à laisser au TTL du Job) d’une session
+    # abandonnée (à supprimer tout de suite).
+    def pod_terminated?(namespace, pod, timeout: "10s")
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + parse_timeout(timeout)
+      loop do
+        return true if TERMINAL_PHASES.include?(pod_phase(namespace, pod))
+        return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        sleep 0.5
+      end
+    end
+
+    def pod_phase(namespace, pod)
+      run("get", "pod", pod, "-n", namespace, "-o", "jsonpath={.status.phase}").strip
+    rescue RuntimeError
+      ""
+    end
+
+    def delete_job(namespace, job)
+      run("delete", "job", job, "-n", namespace, "--ignore-not-found=true", "--wait=false")
+    end
+
+    def follow_job_logs(namespace, job)
+      wait_job_pod(namespace, job)
+      stream_logs("logs", "-n", namespace, "job/#{job}", "-c", OneOffSpec::CONTAINER_NAME, "-f") do |line|
+        puts line
+      end
+    end
+
+    def job_exit_code(namespace, job)
+      json = JSON.parse(run("get", "job", job, "-n", namespace, "-o", "json"))
+      return EXIT_SUCCESS if json.dig("status", "succeeded").to_i >= 1
+
+      pod = job_pod_name(namespace, job)
+      return EXIT_FAILURE if pod.nil?
+
+      pod_json = JSON.parse(run("get", "pod", pod, "-n", namespace, "-o", "json"))
+      statuses = pod_json.dig("status", "containerStatuses") || []
+      statuses.first&.dig("state", "terminated", "exitCode") ||
+        statuses.first&.dig("lastState", "terminated", "exitCode") ||
+        EXIT_FAILURE
+    end
+
+    def wait_job_pod(namespace, job, timeout: "120s")
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + parse_timeout(timeout)
+      loop do
+        name = job_pod_name(namespace, job)
+        return name if name
+
+        raise "aucun pod pour le Job '#{job}' dans '#{namespace}'" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        sleep 0.5
+      end
+    end
+
+    def job_pod_name(namespace, job)
+      output = run(
+        "get", "pod", "-n", namespace, "-l", "job-name=#{job}",
+        "-o", "jsonpath={.items[0].metadata.name}"
+      ).strip
+      output.empty? ? nil : output
+    rescue RuntimeError => e
+      return nil if e.message.include?("index out of bounds") || e.message.include?("array index")
+
+      raise
+    end
+
+    def create_empty_secret_yaml(name, namespace)
+      run("create", "secret", "generic", name, "-n", namespace, "--dry-run=client", "-o", "yaml")
+    end
+
+    def create_secret_yaml(name, vars, namespace: name)
+      literals = vars.map { |k, v| "--from-literal=#{k}=#{v}" }
+      run("create", "secret", "generic", name, "-n", namespace, *literals, "--dry-run=client", "-o", "yaml")
+    end
+
+    def scale(namespace, deployment, replicas)
+      run("scale", "deployment", deployment, "-n", namespace, "--replicas=#{replicas}")
+    end
+
+    def restore(namespace, pod, dump_file, format)
+      cmd = format == :custom ?
+        [ "pg_restore", "--clean", "--if-exists", "--no-owner", "--no-acl", "-d", "app" ] :
+        [ "psql", "app" ]
+      exec_with_file(namespace, pod, dump_file, *cmd)
+    end
+
+    def admin_credentials(namespace, app)
+      [ ADMIN_ROLE, get_secret_password(namespace, ADMIN_SECRET) ]
+    rescue RuntimeError => e
+      raise unless e.message.include?("NotFound")
+
+      [ OWNER_ROLE, postgres_secret_password(namespace, app) ]
+    end
+
+    def psql_file(namespace, pod, file, user:, password:, single_transaction: true)
+      flags = [ "-v", "ON_ERROR_STOP=1" ]
+      flags << "--single-transaction" if single_transaction
+      exec_with_file(namespace, pod, file, *psql_argv(user, password, flags))
+    end
+
+    def psql_interactive(namespace, pod, user:, password:)
+      run_interactive("exec", "-n", namespace, "-it", pod, "--", *psql_argv(user, password))
+    end
+
+    def exec_with_file(namespace, pod, file, *cmd)
+      system("kubectl", *kubeconfig_args, "exec", "-n", namespace, "-i", pod, "--", *cmd, in: File.open(file))
+    end
+
+    def pod_crashing?(namespace, selector)
+      json = run("get", "pod", "-n", namespace, "-l", selector, "-o", "json")
+      items = JSON.parse(json)["items"] || []
+      items.any? do |pod|
+        statuses = (pod.dig("status", "containerStatuses") || []) +
+                   (pod.dig("status", "initContainerStatuses") || [])
+        statuses.any? do |s|
+          s["restartCount"].to_i > 0 ||
+            s.dig("state", "waiting", "reason")&.include?("CrashLoop") ||
+            s.dig("lastState", "terminated", "exitCode").to_i != 0
+        end
+      end
+    end
+
+    def logs(namespace, selector, follow: false, container: nil, previous: false, tail: 100,
+             formatter: Presenter::LogLine.new(app: namespace), filter: LogNoiseFilter.new)
+      args = [ "logs", "-n", namespace, "-l", selector, "--timestamps", "--prefix" ]
+      args << "-f" if follow
+      args << "-p" if previous
+      args += [ "--tail", tail.to_s ] unless follow
+      args += [ "-c", container ] if container
+      success = print_logs(args, formatter, filter)
+      return if success || !previous
+
+      warn "⚠️  Logs du run précédent non disponibles (purgés par le runtime), affichage des logs actuels"
+      print_logs(args - [ "-p" ], formatter, filter)
+    end
+
+    def print_logs(args, formatter, filter)
+      stream_logs(*args) do |line|
+        next if filter.noise?(line)
+
+        puts formatter.call(line)
+      end
+    end
+
+    def run_interactive(*args)
+      system("kubectl", *kubeconfig_args, *args)
+    end
+
+    # external_encoding forcé : sans LANG, Ruby lit en US-ASCII et les octets
+    # UTF-8 des séquences TTY d’une console one-off font planter la lecture.
+    def stream_logs(*args)
+      IO.popen([ "kubectl", *kubeconfig_args, *args ],
+               err: [ :child, :out ], external_encoding: Encoding::UTF_8) do |io|
+        io.each_line { |line| yield line.scrub }
+      end
+      $?.success?
+    end
+
+    def pod_info(namespace, app)
+      output = run(
+        "get", "pod", "-n", namespace, "-l", "app=#{app}",
+        "--field-selector=status.phase=Running",
+        "-o", "jsonpath={.items[0].metadata.name} {.items[0].metadata.creationTimestamp}"
+      ).strip
+      output.empty? ? [ nil, nil ] : output.split(" ", 2)
+    rescue RuntimeError => e
+      return [ nil, nil ] if e.message.include?("index out of bounds") || e.message.include?("array index")
+
+      raise
+    end
+
+    def get_secret_data(namespace, secret_name)
+      json = run("get", "secret", secret_name, "-n", namespace, "-o", "json")
+      data = JSON.parse(json).fetch("data", {})
+      data.transform_values { |v| Base64.strict_decode64(v) }
+    end
+
+    def get_secret_password(namespace, secret_name)
+      encoded = run("get", "secret", secret_name, "-n", namespace,
+                    "-o", "jsonpath={.data.password}").strip
+      Base64.strict_decode64(encoded)
+    end
+
+    def postgres_secret_password(namespace, app)
+      with_cnpg_fallback("postgres-#{app}-app", "postgres-#{app}-cnpg-app") do |name|
+        get_secret_password(namespace, name)
+      end
+    end
+
+    def postgres_pod_name(namespace, app)
+      with_cnpg_fallback("postgres-#{app}-1", "postgres-#{app}-cnpg-1") do |name|
+        run("get", "pod", name, "-n", namespace, "-o", "jsonpath={.metadata.name}")
+        name
+      end
+    end
+
+    def transfer_file_to_pod(namespace, pod, stream_cmd, remote_path)
+      system_pipe("#{stream_cmd} | #{kubectl_cmd} exec -i #{pod} -n #{namespace} -- bash -c 'cat > #{remote_path}'")
+    end
+
+    def dump_from_pod(namespace, pod, local_path, cmd)
+      system_pipe("#{kubectl_cmd} exec #{pod} -n #{namespace} -- bash -c '#{cmd}' > #{Shellwords.escape(local_path)}")
+    end
+
+    def kubeconfig_args
+      @kubeconfig ? [ "--kubeconfig", @kubeconfig ] : []
+    end
+
+    def kubectl_cmd
+      ([ "kubectl" ] + kubeconfig_args).map { |a| Shellwords.escape(a) }.join(" ")
+    end
+
+    def system_pipe(cmd)
+      system("bash", "-c", cmd)
+    end
+
+    def exec_on_pod(namespace, pod, cmd)
+      run_interactive("exec", pod, "-n", namespace, "--", "bash", "-c", cmd)
+    end
+
+    def exec_on_pod_output(namespace, pod, cmd)
+      out, _err, status = Open3.capture3("kubectl", *kubeconfig_args, "exec", pod, "-n", namespace, "--", "bash", "-c", cmd)
+      status.success? ? out : nil
+    end
+
+    def restart_deployment(namespace, name)
+      run("rollout", "restart", "deployment", "-n", namespace, name)
+    end
+
+    def run(*args)
+      out, err, status = Open3.capture3("kubectl", *kubeconfig_args, *args)
+      raise AuthError, "Votre session a expiré. Reconnectez-vous avec : captive login" if err.include?("Unauthorized")
+      raise "kubectl #{args.join(" ")} failed: #{err}" unless status.success?
+
+      out
+    end
+
+    private
+
+    def psql_argv(user, password, flags = [])
+      [ "env", "PGPASSWORD=#{password}",
+        "psql", *flags, "-h", "localhost", "-U", user, "-d", "app", ]
+    end
+
+    def parse_timeout(timeout)
+      case timeout
+      when Integer then timeout
+      when /\A(\d+)s\z/ then Regexp.last_match(1).to_i
+      when /\A(\d+)m\z/ then Regexp.last_match(1).to_i * 60
+      else 120
+      end
+    end
+
+    def with_cnpg_fallback(standard_name, cnpg_name)
+      yield standard_name
+    rescue RuntimeError => e
+      raise unless e.message.include?("NotFound")
+
+      yield cnpg_name
+    end
+  end
+end

data/lib/captive/loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "version"
+require "pastel"
+require "tty-prompt"
+
+require_relative "kubectl"
+require_relative "cluster_apps"
+require_relative "log_noise_filter"
+require_relative "presenter/ansi_stripper"
+require_relative "null_log_filter"
+require_relative "one_off_spec"
+require_relative "session_id"
+require_relative "poller"
+require_relative "gh_cli"
+require_relative "activity_trail"
+require_relative "errors"
+require_relative "ui/spinner"
+require_relative "ui/banner"
+
+require_relative "commands/console"
+require_relative "commands/one_off_session"
+require_relative "commands/run"
+require_relative "commands/logs"
+require_relative "commands/apps_info"
+require_relative "commands/apps_restart"
+require_relative "commands/apps_rebuild"
+require_relative "commands/db_dump"
+require_relative "commands/db_restore"
+
+
+require_relative "presenter/log_line"