captive-cli 1.0.0

data/lib/captive/commands/db_commands.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+require_relative "db_exec"
+require_relative "db_psql"
+
+module Captive
+  module Commands
+    class DbCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "dump APP [OUTPUT_FILE]", "Exporte la base vers un fichier local"
+      long_desc <<~DESC
+        Lance pg_dump dans le pod postgres et rapatrie le dump en local.
+        Format : custom (-Fc), compatible avec `captive db restore`.
+
+        \x05Exemple :
+        \x05  captive db dump my-app
+        \x05  captive db dump my-app /tmp/backup.pgsql
+      DESC
+      def dump(app, output_file = nil)
+        labels = { dumping: "Dump en cours..." }
+        result = DbDump.new(kubectl: kubectl, trail: trail).run(app, output_file) { |step| puts paint.dim("  → #{labels[step]}") }
+        puts paint.green("  ✓ Dump terminé : #{result}")
+      rescue Captive::DumpError => e
+        abort paint.red("✗ #{e.message}")
+      end
+
+      desc "exec APP FICHIER.sql", "Exécute un fichier SQL sur la base"
+      long_desc <<~DESC
+        Joue un fichier SQL sur la base de l'app, sous un rôle admin non-superuser.
+        Par défaut tout ou rien : la moindre erreur annule l'intégralité du fichier.
+
+        \x05Exemple :
+        \x05  captive db exec my-app-staging sql/95_ma_migration.sql
+        \x05  captive db exec my-app-staging sql/95_index.sql --no-transaction
+      DESC
+      method_option :transaction, type: :boolean, default: true,
+                    desc: "Joue le fichier dans une transaction unique " \
+                          "(--no-transaction pour CREATE INDEX CONCURRENTLY, pg_cron…)"
+      def exec(app, file)
+        result = DbExec.new(kubectl: kubectl).run(app, file, single_transaction: options[:transaction])
+        puts paint.green("  ✓ #{result} appliqué.")
+      rescue Errno::ENOENT => e
+        abort paint.red("✗ Fichier introuvable : #{e.message}")
+      rescue Captive::ExecError => e
+        abort paint.red("✗ #{e.message}")
+      end
+
+      desc "psql APP", "Ouvre une session psql interactive sur la base"
+      long_desc <<~DESC
+        Session psql interactive sur la base de l'app, sous un rôle admin
+        non-superuser. L'équivalent du SQL Editor de Supabase, en ligne de commande.
+
+        \x05Exemple :
+        \x05  captive db psql my-app-staging
+      DESC
+      def psql(app)
+        DbPsql.new(kubectl: kubectl).run(app)
+      end
+
+      desc "restore APP DUMP_FILE", "Restaure la base depuis un dump local"
+      long_desc <<~DESC
+        Arrête l'app, restaure la base, relance l'app.
+        Formats : .pgsql, .dump, .tar.gz, .sql, .sql.gz.
+
+        \x05Exemple :
+        \x05  captive db restore my-app dump.pgsql
+        \x05  captive db restore my-app 20260602_backup.tar.gz
+      DESC
+      def restore(app, dump_file)
+        labels = {
+          scaling_down: "Arrêt de l'app...",
+          transferring:  "Transfert du dump...",
+          restoring:     "Restauration...",
+          scaling_up:    "Relance de l'app...",
+        }
+        spinner = restore_spinner
+        DbRestore.new(kubectl: kubectl, trail: trail).run(app, dump_file) do |step, elapsed = nil, info = nil|
+          if step == :waiting
+            spinner.auto_spin unless spinner.spinning?
+            spinner.update(info: (info && !info.empty?) ? info : "en cours... #{elapsed.to_i}s")
+          else
+            spinner.success if spinner.spinning?
+            puts paint.dim("  → #{labels[step]}")
+          end
+        end
+        puts paint.green("  ✓ Restauration terminée.")
+      rescue Errno::ENOENT => e
+        abort paint.red("✗ Fichier introuvable : #{e.message}")
+      rescue Captive::RestoreError => e
+        spinner.error if spinner.spinning?
+        abort paint.red("✗ #{e.message}")
+      end
+
+      private
+
+      def restore_spinner
+        TTY::Spinner.new("  [:spinner] :info", format: :dots)
+      end
+    end
+  end
+end

data/lib/captive/commands/db_dump.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Captive
+  module Commands
+    class DbDump
+      def initialize(kubectl:, trail:)
+        @kubectl = kubectl
+        @trail   = trail
+      end
+
+      def run(app, output_file)
+        @trail.db_dumped(app)
+        output_file ||= default_filename(app)
+        pg_pod        = @kubectl.postgres_pod_name(app, app)
+        password      = @kubectl.postgres_secret_password(app, app)
+        cmd           = "PGPASSWORD='#{password}' pg_dump -h localhost -U app -d app -Fc"
+
+        yield :dumping if block_given?
+        ok = @kubectl.dump_from_pod(app, pg_pod, output_file, cmd)
+        raise DumpError, "Le dump a échoué" if ok == false
+
+        output_file
+      end
+
+      def default_filename(app)
+        base = ENV.fetch("CAPTIVE_ORIG_DIR", Dir.pwd)
+        File.join(base, "#{app}_#{Time.now.strftime("%Y%m%d_%H%M%S")}.pgsql")
+      end
+    end
+  end
+end

data/lib/captive/commands/db_exec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "db_target"
+
+module Captive
+  module Commands
+    class DbExec
+      def initialize(kubectl:, target: DbTarget.new(kubectl: kubectl))
+        @kubectl = kubectl
+        @target  = target
+      end
+
+      def run(app, file, single_transaction: true)
+        pod, user, password = @target.resolve(app)
+        ok = @kubectl.psql_file(app, pod, file,
+                                user: user, password: password, single_transaction: single_transaction)
+        raise ExecError, "L'exécution de #{file} a échoué" if ok == false
+
+        file
+      end
+    end
+  end
+end

data/lib/captive/commands/db_psql.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "db_target"
+
+module Captive
+  module Commands
+    class DbPsql
+      def initialize(kubectl:, target: DbTarget.new(kubectl: kubectl))
+        @kubectl = kubectl
+        @target  = target
+      end
+
+      def run(app)
+        pod, user, password = @target.resolve(app)
+        @kubectl.psql_interactive(app, pod, user: user, password: password)
+      end
+    end
+  end
+end

data/lib/captive/commands/db_restore.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "open3"
+require "shellwords"
+require_relative "../errors"
+require_relative "../poller"
+require_relative "../flux"
+
+module Captive
+  module Commands
+    class DbRestore
+      TEMP_REMOTE = "/controller/tmp/dump.tmp"
+      EXIT_FILE   = "/controller/tmp/restore.exit"
+      LOG_FILE    = "/controller/tmp/restore.log"
+      FLUX_KUSTOMIZATION = "services"
+
+      def initialize(kubectl:, trail:, poller: nil, flux: nil)
+        @kubectl = kubectl
+        @trail   = trail
+        @poller  = poller || Poller.new(interval: 10, timeout: 1800)
+        @flux    = flux || Flux.new
+      end
+
+      def detect_format(filename)
+        basename = File.basename(filename)
+        return :custom if basename.match?(/\.(pgsql|dump|custom|tar\.gz|tgz)$/)
+
+        :sql
+      end
+
+      def postgres_pod(app)
+        @kubectl.postgres_pod_name(app, app)
+      end
+
+      def run(app, dump_file)
+        dump_file = resolve_path(dump_file)
+        raise Errno::ENOENT, dump_file unless File.exist?(dump_file)
+
+        # Après le contrôle du fichier : un dump introuvable n'a touché à rien, l'inscrire au
+        # fil de l'app serait du bruit.
+        @trail.db_restored(app)
+
+        pg_pod    = postgres_pod(app)
+        password  = @kubectl.postgres_secret_password(app, app)
+        format    = detect_format(dump_file)
+        stream    = build_stream_cmd(dump_file)
+
+        yield :scaling_down if block_given?
+        @flux.suspend_kustomization(FLUX_KUSTOMIZATION)
+        @kubectl.scale(app, app, 0)
+
+        begin
+          yield :transferring if block_given?
+          @kubectl.transfer_file_to_pod(app, pg_pod, stream, TEMP_REMOTE)
+          yield :restoring if block_given?
+          on_tick = lambda { |elapsed|
+            activity = @kubectl.exec_on_pod_output(app, pg_pod, current_activity_cmd)
+            yield(:waiting, elapsed, activity&.strip) if block_given?
+          }
+          restore_on_pod(app, pg_pod, password, format, &on_tick)
+          cleanup_pod(app, pg_pod)
+        ensure
+          yield :scaling_up if block_given?
+          @kubectl.scale(app, app, 1)
+          @flux.resume_kustomization(FLUX_KUSTOMIZATION)
+        end
+      end
+
+      private
+
+      def inner_is_custom?(file)
+        inner = `tar -tzf #{Shellwords.escape(file)} 2>/dev/null | grep -Ev '/$' | head -1`.strip
+        inner.match?(/\.(pgsql|dump|custom)$/)
+      end
+
+      def build_stream_cmd(file)
+        basename = File.basename(file)
+        escaped  = Shellwords.escape(file)
+
+        if basename.match?(/\.tar\.gz$|\.tgz$/)
+          inner = `tar -tzf #{escaped} 2>/dev/null | grep -Ev '/$' | head -1`.strip
+          "tar -xOf #{escaped} #{Shellwords.escape(inner)}"
+        elsif basename.match?(/\.(gz)$/)
+          "gunzip -c #{escaped}"
+        else
+          "cat #{escaped}"
+        end
+      end
+
+      def restore_on_pod(app, pg_pod, password, format, &on_tick)
+        pgpass = Shellwords.escape(password)
+        @kubectl.exec_on_pod(app, pg_pod,
+          "PGPASSWORD=#{pgpass} psql -h localhost -U app -d app " \
+          "-c 'DROP SCHEMA public CASCADE; CREATE SCHEMA public; GRANT ALL ON SCHEMA public TO app;' 2>&1")
+
+        cmd = restore_cmd(password, format)
+        inner_script = "#{cmd}; echo $? > #{EXIT_FILE}"
+        @kubectl.exec_on_pod(app, pg_pod,
+          "rm -f #{EXIT_FILE}; nohup bash -c #{Shellwords.escape(inner_script)} > #{LOG_FILE} 2>&1 < /dev/null &")
+
+        exit_code = wait_for_exit_code(app, pg_pod, &on_tick)
+        raise RestoreError, "La restauration a échoué (code #{exit_code})" unless exit_code == "0"
+      end
+
+      def wait_for_exit_code(app, pg_pod, &on_tick)
+        exit_code = nil
+        @poller.poll_until(context: "fin du restore (#{EXIT_FILE})", on_tick: on_tick) do
+          exit_code = @kubectl.exec_on_pod_output(app, pg_pod, "cat #{EXIT_FILE} 2>/dev/null")
+          exit_code && !exit_code.strip.empty?
+        end
+        exit_code.strip
+      end
+
+      def restore_cmd(password, format)
+        pgpass = Shellwords.escape(password)
+        if format == :custom
+          "(PGPASSWORD=#{pgpass} pg_restore --no-owner --no-acl --verbose " \
+          "-h localhost -U app -d app #{TEMP_REMOTE} 2>&1 | grep -v 'no privileges'; exit ${PIPESTATUS[0]})"
+        else
+          "PGPASSWORD=#{pgpass} psql -h localhost -U app -d app < #{TEMP_REMOTE} 2>&1"
+        end
+      end
+
+      def current_activity_cmd
+        "psql -U postgres -d app -tAc " \
+        "\"SELECT query FROM pg_stat_activity WHERE datname='app' AND pid != pg_backend_pid() " \
+        "AND state='active' AND query !~ 'autovacuum' ORDER BY query_start DESC LIMIT 1;\" 2>/dev/null"
+      end
+
+      def cleanup_pod(app, pg_pod)
+        @kubectl.run("exec", pg_pod, "-n", app, "--", "rm", "-f", TEMP_REMOTE)
+      rescue StandardError
+        nil # ignore cleanup errors
+      end
+
+      def resolve_path(path)
+        return path if Pathname.new(path).absolute?
+
+        base = ENV.fetch("CAPTIVE_ORIG_DIR", Dir.pwd)
+        File.join(base, path)
+      end
+    end
+  end
+end

data/lib/captive/commands/db_target.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    # Résout la cible de connexion psql d'une app : le pod primaire du cluster
+    # Postgres, et le rôle sous lequel jouer le SQL de l'utilisateur.
+    class DbTarget
+      def initialize(kubectl:)
+        @kubectl = kubectl
+      end
+
+      def resolve(app)
+        pod            = @kubectl.postgres_pod_name(app, app)
+        user, password = @kubectl.admin_credentials(app, app)
+        [ pod, user, password ]
+      end
+    end
+  end
+end

data/lib/captive/commands/env_kube_commands.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "env_list_kube"
+
+module Captive
+  module Commands
+    class EnvKubeCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "list APP", "Liste les variables d'environnement de l'app depuis K8s"
+      long_desc <<~DESC
+        Lit directement le secret <app>-env depuis le cluster Kubernetes.
+
+        \x05Exemple :
+        \x05  captive env list my-app-staging
+      DESC
+      def list(app)
+        vars = EnvListKube.new(kubectl: kubectl).run(app)
+        vars.sort.each { |v| puts v }
+      end
+    end
+  end
+end

data/lib/captive/commands/env_list_kube.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    class EnvListKube
+      def initialize(kubectl:)
+        @kubectl = kubectl
+      end
+
+      def run(app)
+        data = @kubectl.get_secret_data(app, "#{app}-env")
+        data.map { |k, v| "#{k}=#{v}" }
+      end
+    end
+  end
+end

data/lib/captive/commands/logs.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../log_noise_filter"
+require_relative "../null_log_filter"
+require_relative "../one_off_spec"
+require_relative "../presenter/log_colorizer"
+
+module Captive
+  module Commands
+    # Affiche les logs d'une app en mode live (kubectl) ou historique (Loki via dashboard).
+    class Logs
+      def initialize(kubectl:, dashboard: DashboardClient.new, paint: Pastel.new)
+        @kubectl   = kubectl
+        @dashboard = dashboard
+        @colorizer = Presenter::LogColorizer.new(paint: paint)
+      end
+
+      def run(app, follow: false, container: nil, worker: false, lines: 100, from: nil, to: nil, raw: false)
+        if from || to
+          run_historical(app, from: from, to: to, lines: lines, raw: raw)
+        else
+          run_live(app, follow: follow, container: container, worker: worker, lines: lines, raw: raw)
+        end
+      end
+
+      private
+
+      def run_live(app, follow:, container:, worker:, lines:, raw:)
+        selector = worker ? "app=#{app}-worker" : OneOffSpec.live_logs_selector(app)
+        crashing = !follow && @kubectl.pod_crashing?(app, selector)
+        warn "⚠️  Pod en crash — affichage des logs du dernier run (--previous)" if crashing
+        @kubectl.logs(app, selector, follow: follow, container: container, previous: crashing, tail: lines,
+                      filter: log_filter(raw))
+      end
+
+      def run_historical(app, from:, to:, raw:, **)
+        filter = log_filter(raw)
+        data   = @dashboard.logs(app, start_at: from, end_at: to)
+        lines  = data.reject { |line| filter.noise?(line["text"].to_s) }.map { |line| format_line(line) }
+        with_pager { |out| lines.each { |l| out.puts l } }
+      end
+
+      def log_filter(raw) = raw ? NullLogFilter.new : LogNoiseFilter.new
+
+      def with_pager
+        if $stdout.tty?
+          require "tempfile"
+          Tempfile.create([ "captive-logs", ".txt" ]) do |f|
+            yield f
+            f.flush
+            system("less", "-R", "+1", f.path)
+          end
+        else
+          yield $stdout
+        end
+      end
+
+      def format_line(line)
+        ts, label, message = line.values_at("ts", "process", "text")
+        @colorizer.format_line(ts: ts, label: label || "?", message: message.to_s)
+      end
+    end
+  end
+end

data/lib/captive/commands/one_off_session.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../one_off_spec"
+require_relative "../session_id"
+require_relative "../terminal"
+require_relative "../ui/banner"
+
+module Captive
+  module Commands
+    # Exécute une commande dans un Job one-off qui reprend l'image et l'env de l'app,
+    # attaché devant un TTY (humain), en suivant ses logs sinon (agent, CI, pipe).
+    #
+    # La session est tirée avant tout le reste et remise à l'appelant pour qu'il l'inscrive
+    # au fil, puis elle nomme le Job. Un one-off abandonné avant même sa création laisse donc
+    # une entrée qui pointe vers un log simplement vide, jamais vers la session d'un autre.
+    class OneOffSession
+      def initialize(kubectl:, banner: UI::Banner.new, session_id: SessionId, tty: Terminal.method(:interactive?))
+        @kubectl    = kubectl
+        @banner     = banner
+        @session_id = session_id
+        @tty        = tty
+      end
+
+      def interactive?
+        @tty.call
+      end
+
+      # @return [Integer, nil] exit code of the one-off command (nil when attached)
+      def run(app, command, &register)
+        interactive? ? attach(app, command, &register) : stream(app, command, &register)
+      end
+
+      def attach(app, command)
+        session = @session_id.generate.tap { |id| yield id }
+        @banner.show(app)
+        job = create_job(app, command, session, interactive: true)
+        pod = @kubectl.wait_job_pod(app, job)
+        begin
+          @kubectl.wait_pod_ready(app, pod)
+          @kubectl.attach(app, pod)
+        ensure
+          cleanup(app, job, pod)
+        end
+      end
+
+      private
+
+      def stream(app, command)
+        session = @session_id.generate.tap { |id| yield id }
+        job = create_job(app, command, session, interactive: false)
+        @kubectl.follow_job_logs(app, job)
+        @kubectl.job_exit_code(app, job)
+      end
+
+      def create_job(app, command, session, interactive:)
+        resource = OneOffSpec.new(
+          app: app,
+          deployment: @kubectl.get_deployment_json(app, app),
+          command: command,
+          interactive: interactive,
+          session: session
+        ).to_h
+
+        @kubectl.create_from_resource(resource)
+      end
+
+      # Une session terminée normalement est laissée au TTL du Job : le pod
+      # survit quelques minutes, le temps d'être relu par captive logs. Une
+      # session abandonnée (détachement sans exit) tournerait sinon jusqu'à
+      # activeDeadlineSeconds, on la supprime tout de suite.
+      def cleanup(app, job, pod)
+        @kubectl.delete_job(app, job) unless @kubectl.pod_terminated?(app, pod)
+      end
+    end
+  end
+end

data/lib/captive/commands/run.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "one_off_session"
+
+module Captive
+  module Commands
+    # Verbe unique des one-off (ADR 0017) : la commande passe par sh -c, comme
+    # scalingo run, et la session n'est interactive que devant un TTY.
+    class Run
+      def initialize(kubectl:, trail:, one_off: OneOffSession.new(kubectl: kubectl))
+        @trail   = trail
+        @one_off = one_off
+      end
+
+      # @return [Integer, nil] exit code of the one-off command (nil when attached)
+      def run(app, *cmd)
+        script = cmd.join(" ")
+        @one_off.run(app, [ "sh", "-c", script ]) do |session|
+          @trail.command_run(app, [ script ], session: session)
+        end
+      end
+    end
+  end
+end

data/lib/captive/commands/user_login.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Captive
+  module Commands
+    class UserLogin
+      Browser = Struct.new(:open_cmd) do
+        def open(url) = system(open_cmd, url)
+      end
+
+      def initialize(github:, cluster:, token_path:, kubeconfig_path:,
+                     ui: method(:puts), browser: Browser.new("open"))
+        @github          = github
+        @cluster         = cluster
+        @token_path      = token_path
+        @kubeconfig_path = kubeconfig_path
+        @ui              = ui
+        @browser         = browser
+      end
+
+      def call
+        ensure_dirs
+        device = @github.request_device_code
+        @browser.open(device[:verification_uri])
+        @ui.call("Entre le code sur #{device[:verification_uri]} : #{device[:user_code]}")
+        token = @github.poll_token(device_code: device[:device_code], interval: device[:interval])
+        File.write(@token_path, token)
+        File.chmod(0o600, @token_path)
+        File.write(@kubeconfig_path, kubeconfig_content(token))
+        File.chmod(0o600, @kubeconfig_path)
+      end
+
+      private
+
+      def ensure_dirs
+        [ @token_path, @kubeconfig_path ].each { |p| FileUtils.mkdir_p(File.dirname(p)) }
+      end
+
+      def kubeconfig_content(token)
+        endpoint = @cluster.fetch(token)
+        <<~YAML
+          apiVersion: v1
+          kind: Config
+          clusters:
+            - name: captive
+              cluster:
+                server: #{endpoint[:server]}
+                certificate-authority-data: #{endpoint[:certificate_authority_data]}
+          users:
+            - name: captive-user
+              user:
+                token: #{token}
+          contexts:
+            - name: captive
+              context:
+                cluster: captive
+                user: captive-user
+          current-context: captive
+        YAML
+      end
+    end
+  end
+end