captive-cli 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ec4e1f102b8ed8f597677d727876ad7a0be2996de6cd51de68cb1e4730953e2
+  data.tar.gz: 2a7e112840ea957652e340a70d9586328a65e95cf154b6d5de1a7b3f518a400b
+SHA512:
+  metadata.gz: 84a84d1504ace4bc7ddfc544a930df455297e4f806509f387241371f6f0f256b7ad2d0aee1ed870fc494a9a93eed36ee33e601808f7ee4363b62908e241076f6
+  data.tar.gz: c5ba6f27ac8b9efb857b62c2f241ade477b976717f5225e4e1423b4be3407a88cadb89dc151e220394efa8d5e09c2bae28e215b491258148ba367adc0f046046

data/exe/captive

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "captive/cli"
+
+Captive::CLI.start(ARGV)

data/lib/captive/activity_trail.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "dashboard_client"
+
+module Captive
+  # Ce qu'on signale au dashboard des accès qu'on ouvre sur une app : console, shell, commande
+  # one-off, export et restauration de la base.
+  #
+  # Cette unité change quand les accès qu'on trace changent, là où les commandes changent quand
+  # ce qu'elles font change. Elle porte les `kind`, que le dashboard traduit en événements :
+  # les laisser dans les actions Thor les éparpillait sur cinq commandes.
+  class ActivityTrail
+    def initialize(dashboard: DashboardClient.new)
+      @dashboard = dashboard
+    end
+
+    # `session` n'accompagne que les accès qui tournent dans un Job one-off : eux seuls
+    # laissent un log dans Loki que le dashboard saura rattacher à l'entrée du fil. Un shell
+    # passe par kubectl exec et n'est capturé nulle part, donc n'en porte pas.
+    def console_opened(app, session: nil) = signaler(app, "console", session: session)
+    def db_dumped(app)                    = signaler(app, "db_dump")
+    def db_restored(app)                  = signaler(app, "db_restore")
+
+    def command_run(app, command, session: nil)
+      signaler(app, "run", command: Array(command).join(" "), session: session)
+    end
+
+    private
+
+    # Un dashboard indisponible ne doit jamais empêcher d'ouvrir une console : l'accès est ce
+    # que l'utilisateur a demandé, le signaler ne l'est pas.
+    def signaler(app, kind, command: nil, session: nil)
+      @dashboard.record_activity(app, kind: kind, command: command, session: session)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/captive/cli/dependencies.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Captive
+  module CLIDependencies
+    private
+
+    def kubectl
+      @kubectl ||= begin
+        raise NotAuthenticatedError, "Pas de session active. Lance : captive login" if active_kubeconfig.nil?
+
+        Kubectl.new(kubeconfig: active_kubeconfig) if binary_on_path?("kubectl")
+      end
+    end
+    def gh_cli    = @gh_cli    ||= GhCLI.new
+    def trail     = @trail     ||= ActivityTrail.new
+    def paint     = @paint     ||= Pastel.new
+
+    def active_kubeconfig
+      env_kc = ENV["KUBECONFIG"]
+      return env_kc if env_kc && File.exist?(env_kc)
+
+      user_kc = File.expand_path("~/.config/captive/kubeconfig")
+      user_kc if File.exist?(user_kc)
+    end
+
+    def binary_on_path?(name)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, name)) }
+    end
+
+    def parse_time(value)
+      return nil if value.nil?
+
+      Time.parse(value)
+    rescue ArgumentError
+      abort "Format de date invalide : #{value.inspect}. Exemple : '2026-08-31 23:00' ou '2026-08-31T23:00:00+02:00'"
+    end
+
+    def spin(label, success_msg, &block)
+      UI::Spinner.new(label).run(success_msg: paint.green(success_msg), &block)
+    end
+  end
+end

data/lib/captive/cli.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "loader"
+require_relative "cli/dependencies"
+require_relative "commands/apps_commands"
+require_relative "commands/env_kube_commands"
+require_relative "commands/db_commands"
+require_relative "commands/user_login"
+require_relative "dashboard_client"
+require_relative "github_device_flow"
+require_relative "cluster_endpoint"
+require_relative "update_checker"
+require_relative "shell_completions"
+
+module Captive
+  class CLI < Thor
+    include CLIDependencies
+
+    def self.exit_on_failure? = true
+
+    def self.start(args = ARGV, config = {})
+      args = [ "help", args.first ] if args.length == 2 && %w[--help -h].include?(args.last)
+
+      case UpdateChecker.new.check
+      when :blocked
+        warn "Version #{VERSION} n'est plus supportée. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
+        exit 1
+      when :update_available
+        warn "⚠ Nouvelle version disponible. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
+      end
+      super
+    rescue AuthError, NotAuthenticatedError, NoTtyError => e
+      warn e.message
+      exit 1
+    rescue StandardError => e
+      warn "Une erreur inattendue s'est produite : #{e.message}"
+      warn "Si le problème persiste, contacte l'équipe Captive."
+      exit 1
+    end
+
+    # ── Subcommands ─────────────────────────────────────────────────────────
+    desc "apps SUBCOMMAND", "Gestion des apps"
+    subcommand "apps", Commands::AppsCommands
+
+    desc "db SUBCOMMAND", "Base de données"
+    subcommand "db", Commands::DbCommands
+
+    desc "env SUBCOMMAND", "Variables d'environnement d'une app"
+    subcommand "env", Commands::EnvKubeCommands
+
+    # ── Root commands ────────────────────────────────────────────────────────
+    map "--version" => :version
+    desc "version", "Affiche la version de la CLI"
+    def version = puts VERSION
+
+    desc "login", "Authentifie l'utilisateur via GitHub"
+    long_desc <<~DESC
+      Authentifie l'utilisateur via GitHub Device Flow et génère un kubeconfig.
+
+      \x05Exemple :
+      \x05  captive login
+    DESC
+    def login
+      Commands::UserLogin.new(
+        github:          GithubDeviceFlow.new,
+        cluster:         ClusterEndpoint.new,
+        token_path:      File.expand_path("~/.config/captive/token"),
+        kubeconfig_path: File.expand_path("~/.config/captive/kubeconfig")
+      ).call
+      puts "Authentifié avec succès."
+    end
+
+    desc "console APP", "Ouvre une console Rails (pod one-off)"
+    long_desc <<~DESC
+      Lance un pod one-off avec la même image/env que l'app, y attache une
+      console Rails interactive. L'entrée/sortie est capturée dans les logs
+      (Promtail → Loki) et reste visible via captive logs.
+
+      \x05Exemple :
+      \x05  captive console my-app
+    DESC
+    def console(app)
+      Commands::Console.new(trail: trail, one_off: Commands::OneOffSession.new(kubectl: kubectl)).run(app)
+    end
+
+    desc "run APP CMD", "Exécute une commande (Job one-off)"
+    long_desc <<~DESC
+      Lance un Job Kubernetes one-off avec la même image/env que l'app et y
+      exécute CMD via sh -c. Depuis un terminal, la session est interactive ;
+      sans TTY (agent, CI, pipe), la sortie est streamée et le code retour
+      propagé. Dans les deux cas elle est conservée dans les logs.
+
+      \x05Exemple :
+      \x05  captive run my-app "bash"
+      \x05  captive run my-app "rake db:migrate"
+      \x05  captive run my-app "bundle exec rails runner 'puts User.count'"
+    DESC
+    map "run" => :run_cmd
+    def run_cmd(app, *cmd)
+      exit_code = Commands::Run.new(kubectl: kubectl, trail: trail).run(app, *cmd)
+      exit(exit_code) if exit_code && exit_code != 0
+    end
+
+    desc "whoami", "Affiche l'identité K8s courante"
+    def whoami
+      puts kubectl.run("auth", "whoami")
+    end
+
+    desc "completions SHELL", "Génère le script de complétion shell (bash ou zsh)"
+    long_desc <<~DESC
+      Génère un script de complétion pour bash ou zsh.
+
+      \x05Exemple :
+      \x05  eval "$(captive completions bash)"
+      \x05  eval "$(captive completions zsh)"
+    DESC
+    def completions(shell)
+      case shell
+      when "bash" then print ShellCompletions.bash
+      when "zsh"  then print ShellCompletions.zsh
+      else abort "Shell non supporté : #{shell}. Utilise bash ou zsh."
+      end
+    end
+
+    desc "logs APP", "Affiche les logs de l'app"
+    long_desc <<~DESC
+      MODE TEMPS RÉEL (défaut) — stream les logs kubectl du pod running.
+        -f, --follow          Suit en continu (Ctrl+C pour arrêter)
+        -n, --lines N         Nombre de lignes affichées (défaut : 100)
+        -c, --container NOM   Container spécifique (ex : migrate, redis)
+        -w, --worker          Cible le pod worker au lieu du pod web
+        --raw                 Garde les lignes rack-timeout de la readinessProbe
+      En cas de CrashLoopBackOff, --previous est activé automatiquement.
+
+      MODE HISTORIQUE (--from / --to) — interroge Loki via le dashboard.
+        --from DATE           Début de la plage (requis pour ce mode)
+        --to DATE             Fin de la plage (défaut : maintenant)
+        -n, --lines N         Nombre de lignes max (défaut : 100)
+      Requiert d'être authentifié (captive login). Rétention : 28 jours.
+      Formats de date acceptés : "2026-08-31 23:00", "2026-08-31T21:00:00Z".
+
+      \x05Exemples :
+      \x05  captive logs my-app
+      \x05  captive logs my-app -f
+      \x05  captive logs my-app -n 200
+      \x05  captive logs my-app -c migrate
+      \x05  captive logs my-app --worker
+      \x05  captive logs my-app --raw
+      \x05  captive logs my-app --from "2026-08-31 23:00" --to "2026-09-01 00:00"
+      \x05  captive logs my-app --from "2026-08-31 23:00"
+    DESC
+    method_option :follow,    aliases: "-f", type: :boolean, default: false
+    method_option :container, aliases: "-c", type: :string
+    method_option :worker,    aliases: "-w", type: :boolean, default: false
+    method_option :lines,     aliases: "-n", type: :numeric, default: 100
+    method_option :raw,       type: :boolean, default: false, desc: "Affiche le bruit rack-timeout des sondes readiness"
+    method_option :from,      type: :string,  desc: "Début de la plage (ex: '2026-08-31 23:00' ou ISO8601)"
+    method_option :to,        type: :string,  desc: "Fin de la plage (ex: '2026-09-01 00:00' ou ISO8601)"
+    def logs(app)
+      from = parse_time(options[:from])
+      to   = parse_time(options[:to])
+      Commands::Logs.new(kubectl: kubectl).run(
+        app, follow: options[:follow], container: options[:container],
+             worker: options[:worker], lines: options[:lines],
+             from: from, to: to, raw: options[:raw]
+      )
+    end
+  end
+end

data/lib/captive/cluster_apps.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Captive
+  # Ce que le cluster sait des apps déployées. Le CLI développeur décrit l'état réellement
+  # servi, pas l'état désiré dans le repo GitOps — auquel il n'a pas accès.
+  class ClusterApps
+    def initialize(kubectl:)
+      @kubectl = kubectl
+    end
+
+    def all
+      web_deployments.map do |deployment|
+        namespace = deployment.dig("metadata", "namespace")
+        { name: namespace, stage: stage_of(namespace), domains: domains_by_namespace[namespace] || [] }
+      end
+    end
+
+    def domains(app) = domains_by_namespace[app] || []
+
+    def stage(app) = stage_of(app)
+
+    def tier(app) = web_of(app)&.dig("metadata", "annotations", "captive.dev/tier")
+
+    def workers(app) = of_type(app, "worker").map { |d| d.dig("metadata", "name") }
+
+    # L'add-on peut ne pas être posé, ou la CRD absente du cluster : les deux se lisent
+    # comme « pas d'IP fixe », pas comme une panne.
+    def egress_ip(app)
+      first_item("egresspolicy", app)&.dig("spec", "egressIP", "ipv4")
+    end
+
+    def postgres(app)
+      spec = first_item("cluster", app)&.fetch("spec", nil) or return nil
+
+      { instances: spec["instances"],
+        memory:    spec.dig("resources", "limits", "memory"),
+        storage:   spec.dig("storage", "size"), }.compact
+    end
+
+    private
+
+    def first_item(kind, app)
+      items(@kubectl.run("get", kind, "-n", app, "-o", "json")).first
+    rescue RuntimeError
+      nil
+    end
+
+    def web_of(app) = of_type(app, "web").first
+
+    def of_type(app, type)
+      workloads(app).select { |d| d.dig("metadata", "labels", "captive.dev/type") == type }
+    end
+
+    def workloads(app)
+      @workloads ||= {}
+      @workloads[app] ||= items(@kubectl.run("get", "deployment", "-n", app, "-o", "json"))
+    end
+
+
+    # Une app est un Deployment portant le type web : le même label que les composants de
+    # tier ciblent, et que la conformité exige.
+    def web_deployments
+      items(@kubectl.run("get", "deployment", "-A", "-l", "captive.dev/type=web", "-o", "json"))
+    end
+
+    def domains_by_namespace
+      @domains_by_namespace ||= items(@kubectl.run("get", "httproute", "-A", "-o", "json"))
+                                .group_by { |route| route.dig("metadata", "namespace") }
+                                .transform_values { |routes| routes.flat_map { |r| Array(r.dig("spec", "hostnames")) } }
+    end
+
+    def items(json) = JSON.parse(json).fetch("items", [])
+
+    def stage_of(namespace)
+      return "production" if namespace.end_with?("-production")
+
+      "staging" if namespace.end_with?("-staging")
+    end
+  end
+end

data/lib/captive/cluster_endpoint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "http_client"
+require_relative "errors"
+
+module Captive
+  # Où joindre le cluster : le gem est public, il ne porte ni l'adresse du kube-apiserver ni
+  # son CA (ADR 0018). Le dashboard les sert à tout utilisateur authentifié.
+  class ClusterEndpoint
+    URL = "https://dashboard.captive.dev/api/cluster"
+
+    def initialize(http: HttpClient.new)
+      @http = http
+    end
+
+    def fetch(token)
+      data = @http.get(URL, "Authorization" => "Bearer #{token}")
+      { server: data.fetch("server"), certificate_authority_data: data.fetch("certificate_authority_data") }
+    rescue KeyError, JSON::ParserError
+      raise AuthError, "Le dashboard n'a pas fourni l'adresse du cluster. Réessaie : captive login"
+    end
+  end
+end

data/lib/captive/commands/apps_commands.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    class AppsCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "list", "Liste toutes les apps déployées sur la plateforme"
+      long_desc <<~DESC
+        Liste les apps déployées sur le cluster, avec leurs domaines et leur stage.
+
+        \x05Exemple :
+        \x05  captive apps list
+      DESC
+      def list
+        apps = ClusterApps.new(kubectl: kubectl).all
+        puts paint.bold("Apps (#{apps.size}) :")
+        apps.each do |app|
+          stage_badge = case app[:stage]
+          when "staging"    then " " + paint.yellow("[staging]")
+          when "production" then " " + paint.green("[prod]")
+          else ""
+          end
+          puts "  - #{paint.bold(app[:name])}#{stage_badge}"
+          if app[:domains]&.any?
+            app[:domains].each { |d| puts "      #{paint.cyan("https://#{d}")}" }
+          else
+            puts paint.dim("      <no domain>")
+          end
+        end
+      end
+
+      desc "info APP", "Affiche le statut et les infos de l'app"
+      long_desc <<~DESC
+        Affiche l'état complet : pod, replicas, stage, tier, domaines, addons.
+
+        \x05Exemple :
+        \x05  captive apps info my-app
+      DESC
+      def info(app)
+        i = AppsInfo.new(kubectl: kubectl).gather(app)
+        puts paint.bold("\n#{app}")
+        puts "  Stage    : #{i[:stage] || "–"}"
+        puts "  Tier     : #{i[:tier]  || "–"}"
+        puts "  Pod      : #{i[:pod_status]} (#{i[:replicas]} replica(s))"
+        puts "  Postgres : #{i[:postgres]  ? paint.green("✓") : paint.dim("–")}"
+        puts "  Redis    : #{i[:redis]     ? paint.green("✓") : paint.dim("–")}"
+        puts "  IP fixe  : #{i[:egress_ip] ? paint.green("✓") : paint.dim("–")}"
+        i[:domains]&.any? && i[:domains].each { |d| puts "    → #{d}" }
+        i[:workers]&.any? && puts("  Workers  : #{i[:workers].join(", ")}")
+        (pg = i[:postgres_details])  && puts("  Postgres : #{pg[:instances] || 1} instance(s), #{pg[:memory] || "–"} RAM")
+        (rd = i[:redis_details])     && puts("  Redis    : #{rd[:memory] || "–"} RAM, #{rd[:storage] || "–"}")
+        (eg = i[:egress_ip_details]) && puts("  IP fixe  : #{eg[:ip] || "–"}")
+        puts
+      end
+
+      desc "restart APP", "Redémarre le deployment"
+      long_desc <<~DESC
+        Rollout restart du deployment + attend pod Ready.
+
+        \x05Exemple :
+        \x05  captive apps restart my-app
+      DESC
+      def restart(app)
+        AppsRestart.new(kubectl: kubectl).run(app)
+        pod_name, created_at = kubectl.pod_info(app, app)
+        age = format_age(created_at)
+        puts paint.green("  ✓ #{app} redémarré")
+        puts paint.dim("    pod: #{pod_name} (#{age})")
+      rescue PollTimeout => e
+        abort paint.red("✗ Timeout : #{e.message}")
+      rescue RuntimeError => e
+        abort paint.red("✗ #{e.message.split("failed: ").last}")
+      end
+
+      desc "rebuild APP", "Déclenche un rebuild sans changer le code"
+      long_desc <<~DESC
+        workflow_dispatch sur le repo GitHub. Utile après changement d'env vars.
+
+        \x05Exemple :
+        \x05  captive apps rebuild my-app-staging
+      DESC
+      def rebuild(app)
+        AppsRebuild.new(gh: gh_cli).run(app)
+        puts paint.green("  ✓ Rebuild déclenché pour '#{app}'")
+      rescue WorkflowDispatchNotConfigured, ImageYamlNotFound, PlatformRootNotFound => e
+        abort paint.red("✗ #{e.message}")
+      end
+
+      private
+
+      def format_age(created_at)
+        return "?" unless created_at
+
+        require "time"
+        "#{((Time.now - Time.parse(created_at)) / 60).round}s"
+      rescue ArgumentError
+        "?"
+      end
+    end
+  end
+end

data/lib/captive/commands/apps_info.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    # L'état d'une app tel que le cluster le sert. Le CLI développeur n'a pas accès au repo
+    # GitOps : tout se lit sur les ressources vivantes, ce qui décrit l'état réel plutôt que
+    # l'état désiré — un déploiement en cours s'y voit, un manifeste poussé mais non
+    # réconcilié ne s'y voit pas encore.
+    class AppsInfo
+      TIER_RESOURCES = {
+        "xs" => { cpu: "100m → 500m", memory: "256Mi → 512Mi" },
+        "s"  => { cpu: "250m → 1",    memory: "512Mi → 1Gi"   },
+        "m"  => { cpu: "500m → 2",    memory: "1Gi → 2Gi"     },
+        "l"  => { cpu: "1 → 4",       memory: "2Gi → 4Gi"     },
+      }.freeze
+
+      def initialize(kubectl:, cluster_apps: nil)
+        @kubectl = kubectl
+        @apps    = cluster_apps || ClusterApps.new(kubectl: kubectl)
+      end
+
+      def gather(app)
+        tier     = @apps.tier(app)
+        postgres = @apps.postgres(app)
+        egress   = @apps.egress_ip(app)
+        {
+          pod_status: pod_status(app),
+          replicas:   replicas(app),
+          postgres:   !postgres.nil?,
+          redis:      redis?(app),
+          egress_ip:  !egress.nil?,
+          tier:       tier,
+          resources:  TIER_RESOURCES[tier],
+          domains:    @apps.domains(app),
+          stage:      @apps.stage(app),
+          workers:    @apps.workers(app),
+          postgres_details:  postgres,
+          redis_details:     redis_details(app),
+          egress_ip_details: egress && { ip: egress },
+        }
+      end
+
+      private
+
+      def pod_status(app)
+        @kubectl.run("get", "pod", "-n", app, "-l", "app=#{app}",
+                     "-o", "jsonpath={.items[0].status.phase}").strip
+      end
+
+      def replicas(app)
+        @kubectl.run("get", "deployment", app, "-n", app,
+                     "-o", "jsonpath={.spec.replicas}").strip.to_i
+      end
+
+      def redis?(app)
+        !@kubectl.run("get", "deployment", "-n", app, "-l", "app=redis",
+                      "--no-headers", "-o", "name").strip.empty?
+      end
+
+      # Redis est un Deployment ordinaire : sa taille se lit sur le conteneur, pas sur une CRD.
+      def redis_details(app)
+        limits = @kubectl.run(
+          "get", "deployment", "-n", app, "-l", "app=redis",
+          "-o", "jsonpath={.items[0].spec.template.spec.containers[0].resources.limits.memory}"
+        ).strip
+        limits.empty? ? nil : { memory: limits }
+      end
+    end
+  end
+end

data/lib/captive/commands/apps_rebuild.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../platform_root"
+
+module Captive
+  module Commands
+    class AppsRebuild
+      # Dernière commande du CLI développeur qui lit le repo GitOps, contre l'ADR 0016.
+      # Elle déduit le repo GitHub de l'image, or les images valent
+      # ghcr.io/captive-studio/captive-platform/<app> : la déduction rend trois segments, qui
+      # ne désignent aucun repo. Rien dans le service ni sur le cluster n'enregistre le repo
+      # d'origine, donc la commande n'est pas portable en l'état — voir la note de l'étape 9.
+      # Elle exige donc un clone de captive-platform (PlatformRoot), jusqu'à passer par l'API
+      # du dashboard.
+      def initialize(gh:, repo_root: nil)
+        @gh        = gh
+        @repo_root = repo_root
+      end
+
+      def run(app)
+        repo    = extract_repo(app)
+        version = current_version(app)
+        fields  = version ? { version: version } : {}
+        @gh.trigger_workflow(repo, ref: "main", fields: fields)
+      end
+
+      private
+
+      def repo_root = @repo_root ||= PlatformRoot.find
+
+      def extract_repo(app)
+        image_file = File.join(repo_root, "services", app, "image.yaml")
+        raise ImageYamlNotFound, "image.yaml introuvable pour '#{app}'" unless File.exist?(image_file)
+
+        content = File.read(image_file)
+        image   = content.match(/image:\s+ghcr\.io\/([^\s:]+)/)&.captures&.first
+        raise ImageYamlNotFound, "image introuvable dans image.yaml de '#{app}'" unless image
+
+        image
+      end
+
+      def current_version(app)
+        deploy_file = File.join(repo_root, "services", app, "#{app}.yaml")
+        return nil unless File.exist?(deploy_file)
+
+        tag = File.read(deploy_file).match(/:(v\d+\.\d+\.\d+(?:-\d{14})?)/)&.captures&.first
+        tag&.sub(/-\d{14}$/, "")
+      end
+    end
+  end
+end

data/lib/captive/commands/apps_restart.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../poller"
+require_relative "../errors"
+
+module Captive
+  module Commands
+    class AppsRestart
+      def initialize(kubectl:, poller: nil)
+        @kubectl = kubectl
+        @poller  = poller || Poller.new(interval: 5, timeout: 120)
+      end
+
+      def run(app)
+        old_pod, = @kubectl.pod_info(app, app)
+        @kubectl.restart_deployment(app, app)
+        @poller.poll_until(context: "nouveau pod #{app} Running") do
+          new_pod, = @kubectl.pod_info(app, app)
+          new_pod && !new_pod.empty? && new_pod != old_pod
+        end
+      end
+    end
+  end
+end

data/lib/captive/commands/console.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "one_off_session"
+
+module Captive
+  module Commands
+    # Raccourci Rails de captive run. Une console sans TTY quitterait sur EOF :
+    # on refuse avant de créer le Job et on indique le chemin non interactif.
+    class Console
+      COMMAND = [ "bundle", "exec", "rails", "console" ].freeze
+
+      def initialize(trail:, one_off:)
+        @trail   = trail
+        @one_off = one_off
+      end
+
+      def run(app)
+        raise NoTtyError, no_tty_message(app) unless @one_off.interactive?
+
+        @one_off.attach(app, COMMAND) { |session| @trail.console_opened(app, session: session) }
+      end
+
+      private
+
+      def no_tty_message(app)
+        "captive console exige un terminal interactif (TTY). " \
+          "Sans TTY, utilise : captive run #{app} \"bundle exec rails runner '<ruby>'\""
+      end
+    end
+  end
+end