captive-cli 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 377f77798282f817bcd1632482c5075ca10f8c65f1b5ce9abc4e7d3f1aeae2ee
-  data.tar.gz: ef1dc980b18c772c703a7b94ee35a3c35049b22d84ffeca742ee5ce569a32f7e
+  metadata.gz: a31d2e7433e7b31ac59e131ba6a4ffd55732c3e71641fd5e22a45340e8f3f814
+  data.tar.gz: 72b86e63fd6a755f22fab06fd60f1eff32fab9dd8f2c1dfff7a485b11e1a0cd2
 SHA512:
-  metadata.gz: e058db4108f3da4be9dd9c6e5699f1cdb5419463cfe93300cd96dbd8bf612894f23bf97fab095480edc22e70a9c98f4e172e56edb78e8c1108bac3c66b1918be
-  data.tar.gz: 8f199adf232216645878442735570e5ee04a70dd4a8f43031bd0e24d67c12f7af7f5ab8ba7e4de2accfb6143a5801f09fa5b173cf80ed88a9e43ceff5d31a3f2
+  metadata.gz: a4b15fc087ba7cc009d657b7ce9d0f5738b141d423797d25ab435c43e2aa77442b408db411772dbf1cc3a7b7244c087c56668d6d89c0ccd418fd18a2ce41d6e5
+  data.tar.gz: 688bfa7d022d5a4e7605624741153fbb84c0aa9ba90c677035acb87b6935d1febec027421ec3762360ce6fda3ea9c840a9d52f48b816da57a8feffb02caa3da4

data/lib/captive/cli/dependencies.rb

@@ -25,6 +25,7 @@ module Captive
     def env_api   = @env_api   ||= Dashboard::EnvVarsResource.new(api: dashboard)
     def crons_api = @crons_api ||= Dashboard::ScheduledTasksResource.new(api: dashboard)
     def domains_api = @domains_api ||= Dashboard::DomainsResource.new(api: dashboard)
+    def addons_api  = @addons_api  ||= Dashboard::AddonsResource.new(api: dashboard)
 
     def active_kubeconfig
       env_kc = ENV["KUBECONFIG"]

data/lib/captive/cli.rb

@@ -7,6 +7,7 @@ require_relative "commands/apps_commands"
 require_relative "commands/env_commands"
 require_relative "commands/crons_commands"
 require_relative "commands/domains_commands"
+require_relative "commands/addons_commands"
 require_relative "commands/db_commands"
 require_relative "commands/user_login"
 require_relative "commands/auth_commands"
@@ -66,6 +67,9 @@ module Captive
     desc "domains SUBCOMMAND", "Domaines d'une app"
     subcommand "domains", Commands::DomainsCommands
 
+    desc "addons SUBCOMMAND", "Add-ons d'une app (bases, Supabase…)"
+    subcommand "addons", Commands::AddonsCommands
+
     desc "auth SUBCOMMAND", "Jeton pour kubectl", hide: true
     subcommand "auth", Commands::AuthCommands
 
@@ -146,13 +150,12 @@ module Captive
 
     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.
+      MODE TEMPS RÉEL (défaut) — dernières lignes du web et des one-offs, via le dashboard.
         -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
+        -w, --worker          Affiche le worker au lieu du web
         --raw                 Garde les lignes rack-timeout de la readinessProbe
-      En cas de CrashLoopBackOff, --previous est activé automatiquement.
+      Il suffit d'être Membre de l'Organization de l'app, sans accès au repo GitHub.
 
       MODE HISTORIQUE (--from / --to) — interroge Loki via le dashboard.
         --from DATE           Début de la plage (requis pour ce mode)
@@ -165,14 +168,12 @@ module Captive
       \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"
@@ -181,9 +182,8 @@ module Captive
     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],
+      Commands::Logs.new.run(
+        app, follow: options[:follow], worker: options[:worker], lines: options[:lines],
              from: from, to: to, raw: options[:raw]
       )
     end

data/lib/captive/commands/addons_commands.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    # Les Add-ons d'une app via le dashboard (ADR 0034) : tout ce que la page Add-ons permet,
+    # sans quitter le terminal. L'ajout est réservé aux admins de l'organisation.
+    class AddonsCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "list APP", "Liste les add-ons de l'app et leur statut"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive addons list my-app-staging
+      DESC
+      def list(app)
+        installed = addons_api.list(app)["installed"]
+        return puts(paint.dim("Aucun add-on. Voir : captive addons catalog #{app}")) if installed.empty?
+
+        installed.each { |addon| puts presenter.installed(addon) }
+      end
+
+      desc "catalog APP", "Liste les add-ons qu'on peut ajouter à l'app"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive addons catalog my-app-staging
+      DESC
+      def catalog(app)
+        addons_api.list(app)["catalog"].each { |entry| puts presenter.catalog(entry) }
+      end
+
+      desc "add APP ADDON", "Ajoute un add-on à l'app (postgres, supabase…)"
+      long_desc <<~DESC
+        Un add-on « sur demande » (redis, egress-ip) prévient l'équipe plateforme au lieu de
+        l'ajouter. Réservé aux admins de l'organisation.
+
+        \x05Exemple :
+        \x05  captive addons add my-app-staging supabase
+      DESC
+      def add(app, addon)
+        result = addons_api.add(app, addon)
+        if result["status"] == "requested"
+          puts paint.green("  ✓ #{addon} demandé à l'équipe plateforme")
+        else
+          puts paint.green("  ✓ #{addon} en cours d'ajout : #{ASYNC_NOTICE}")
+          puts paint.dim("  Suivre : captive addons list #{app}")
+        end
+      end
+
+      desc "auth APP", "Affiche les réglages d'authentification de l'add-on Supabase"
+      long_desc <<~DESC
+        Auto-confirmation des emails et inscriptions ouvertes, en lecture seule : seule
+        l'équipe plateforme les modifie.
+
+        \x05Exemple :
+        \x05  captive addons auth my-app-staging
+      DESC
+      def auth(app)
+        Presenter::SupabaseAuth.new(paint: paint).lines(addons_api.supabase_auth(app), app: app).each { |line| puts line }
+      end
+
+      private
+
+      def presenter = Presenter::Addon.new(paint: paint)
+    end
+  end
+end

data/lib/captive/commands/logs.rb

@@ -2,36 +2,47 @@
 
 require "time"
 require_relative "../log_noise_filter"
+require_relative "../log_stream"
 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).
+    # Affiche les logs d'une app, toujours via le dashboard (Loki) : seule l'Organization décide
+    # de l'accès, plus le repo GitHub. Dernières lignes, suivi en direct (-f) ou plage (--from/--to).
     class Logs
-      def initialize(kubectl:, dashboard: DashboardClient.new, paint: Pastel.new)
-        @kubectl   = kubectl
+      WORKER = "worker"
+
+      def initialize(dashboard: DashboardClient.new, stream: LogStream.new, paint: Pastel.new)
         @dashboard = dashboard
+        @stream    = stream
         @colorizer = Presenter::LogColorizer.new(paint: paint)
       end
 
-      def run(app, follow: false, container: nil, worker: false, lines: 100, from: nil, to: nil, raw: false)
+      def run(app, follow: false, worker: false, lines: 100, from: nil, to: nil, raw: false)
         if from || to
-          run_historical(app, from: from, to: to, lines: lines, raw: raw)
+          run_historical(app, from: from, to: to, raw: raw)
         else
-          run_live(app, follow: follow, container: container, worker: worker, lines: lines, raw: raw)
+          run_live(app, follow: follow, 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))
+      def run_live(app, follow:, worker:, lines:, raw:)
+        printer = live_printer(worker, log_filter(raw))
+        follow ? @stream.call(app, tail: lines, &printer) : @dashboard.logs(app, limit: lines).each(&printer)
+      rescue Interrupt
+        nil
+      end
+
+      # Comme le sélecteur kubectl d'avant : le web et les one-offs, ou le worker seul.
+      def live_printer(worker, filter)
+        lambda do |line|
+          next if (line["process"] == WORKER) != worker || filter.noise?(line["text"].to_s)
+
+          $stdout.puts format_line(line)
+        end
       end
 
       def run_historical(app, from:, to:, raw:, **)

data/lib/captive/dashboard/addons_resource.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Captive
+  module Dashboard
+    # Les Add-ons d'une app et le Catalogue (ADR 0034) : la même API que la page Add-ons du
+    # dashboard. Un ajout est appliqué plus tard par captive-platform (réponse 202).
+    class AddonsResource
+      PATH = AppPath.new("addons")
+      SUPABASE_AUTH_PATH = AppPath.new("addons/supabase/auth")
+
+      def initialize(api:)
+        @api = api
+      end
+
+      def list(app)       = @api.get(PATH.call(app))
+      def add(app, addon) = @api.post(PATH.call(app), { addon: addon })
+
+      # En lecture seule : seule l'équipe plateforme modifie ces réglages, dans le dépôt GitOps.
+      def supabase_auth(app) = @api.get(SUPABASE_AUTH_PATH.call(app))
+    end
+  end
+end

data/lib/captive/kubectl.rb

@@ -4,9 +4,7 @@ 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
@@ -174,42 +172,6 @@ module Captive
       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

data/lib/captive/loader.rb

@@ -18,9 +18,12 @@ require_relative "dashboard/apps_resource"
 require_relative "dashboard/env_vars_resource"
 require_relative "dashboard/scheduled_tasks_resource"
 require_relative "dashboard/domains_resource"
+require_relative "dashboard/addons_resource"
 require_relative "presenter/app_info"
 require_relative "presenter/scheduled_task"
 require_relative "presenter/domain"
+require_relative "presenter/addon"
+require_relative "presenter/supabase_auth"
 require_relative "activity_trail"
 require_relative "errors"
 require_relative "ui/spinner"
@@ -35,6 +38,3 @@ require_relative "commands/domain_wait"
 require_relative "commands/domain_announcer"
 require_relative "commands/db_dump"
 require_relative "commands/db_restore"
-
-
-require_relative "presenter/log_line"

data/lib/captive/log_stream.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "dashboard_client"
+require_relative "dashboard_response"
+require_relative "session_token"
+require_relative "sse_parser"
+
+module Captive
+  # Suit les logs d'une app en direct, en Server-Sent Events depuis le dashboard
+  # (`GET /api/apps/:id/logs/stream`). Le dashboard ferme le flux au bout de quelques minutes :
+  # on se reconnecte alors avec le dernier id reçu, l'horodatage de la dernière ligne, pour
+  # reprendre sans perte ni doublon. Seul Ctrl+C (Interrupt) ou un refus du dashboard l'arrête.
+  class LogStream
+    RECONNECT_DELAY = 1
+    NETWORK_ERRORS = [ IOError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError ].freeze
+
+    def initialize(session: SessionToken.new)
+      @session = session
+    end
+
+    def self.stream_uri(app, tail)
+      uri       = URI.parse("#{DashboardClient::DASHBOARD_URL}/api/apps/#{URI.encode_uri_component(app)}/logs/stream")
+      uri.query = URI.encode_www_form(tail:)
+      uri
+    end
+
+    def self.headers(last_id)
+      last_id ? { "Accept" => "text/event-stream", "Last-Event-ID" => last_id } : { "Accept" => "text/event-stream" }
+    end
+
+    def self.read(response, &)
+      DashboardResponse.new(response).parse unless response.code.to_i == 200
+      response.read_body(&)
+    end
+
+    def call(app, tail:, &)
+      uri      = self.class.stream_uri(app, tail)
+      @last_id = nil
+      loop do
+        follow(uri, &)
+      rescue *NETWORK_ERRORS
+        sleep RECONNECT_DELAY
+      end
+    end
+
+    private
+
+    # @last_id avance à chaque événement, pas en fin de connexion : une coupure réseau ne doit
+    # pas faire reprendre plus tôt, ce qui réafficherait des lignes.
+    def follow(uri, &)
+      parser = SseParser.new
+      open_stream(uri, self.class.headers(@last_id)) { |chunk| relay(parser, chunk, &) }
+    end
+
+    def relay(parser, chunk)
+      parser.feed(chunk) do |event|
+        @last_id = event[:id] || @last_id
+        yield JSON.parse(event[:data])
+      end
+    end
+
+    # Pas de read_timeout court : le flux reste ouvert, le serveur envoie un battement de cœur.
+    def open_stream(uri, headers, &)
+      @session.authorize do |token|
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 60) do |http|
+          request = Net::HTTP::Get.new(uri, headers.merge("Authorization" => "Bearer #{token}"))
+          http.request(request) { |response| self.class.read(response, &) }
+        end
+      end
+    end
+  end
+end

data/lib/captive/one_off_spec.rb

@@ -45,10 +45,6 @@ module Captive
       "#{app}-run"
     end
 
-    def self.live_logs_selector(app)
-      "app in (#{app},#{run_app_label(app)})"
-    end
-
     private
 
     def job_manifest

data/lib/captive/presenter/addon.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # Une ligne par Add-on présent (« Les vôtres ») ou proposé (« Catalogue »).
+    class Addon
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def installed(addon)
+        details = [ addon["name"], addon["tier"]&.upcase ].compact.join("  ")
+        [ @paint.bold(addon["addon"]), details, status(addon["status"]) ].reject(&:empty?).join("  ")
+      end
+
+      def catalog(entry)
+        head = "#{@paint.bold(entry["id"])}  #{entry["description"]}"
+        notes = []
+        notes << "inclut #{entry["includes"].join(", ")}" if entry["includes"].any?
+        notes << "sur demande" if entry["mode"] == "request"
+        notes << @paint.green("ajouté") if entry["installed"]
+        notes.empty? ? head : "#{head}  #{@paint.dim("(#{notes.join(", ")})")}"
+      end
+
+      private
+
+      def status(value) = value == "ready" ? @paint.green("✓") : @paint.yellow("en cours")
+    end
+  end
+end

data/lib/captive/presenter/app_info.rb

@@ -26,6 +26,8 @@ module Captive
       end
 
       def workload(entry)
+        return "#{entry["name"]} #{@paint.yellow(entry["status_reason"])}" if entry["status"] == "config_required"
+
         ready = "#{entry["ready"]}/#{entry["total"]}"
         ready = @paint.yellow(ready) unless entry["ready"] == entry["total"]
         "#{entry["name"]} #{ready} prêt(s), tier #{entry["tier"] || "–"}"

data/lib/captive/presenter/supabase_auth.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # Les réglages d'authentification de l'Add-on Supabase, en lecture seule comme sur la page
+    # du dashboard : une valeur que le dashboard n'a pas pu lire reste « inconnu ».
+    class SupabaseAuth
+      VALEURS = { true => "oui", false => "non" }.freeze
+
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def lines(settings, app:)
+        [
+          [ "Auto-confirmation des emails", valeur(settings["autoconfirm"]), alerte(settings, app) ].compact.join("  "),
+          "Inscriptions ouvertes  #{valeur(settings["signup_open"])}",
+          @paint.dim("Modifiable par l'équipe plateforme"),
+        ]
+      end
+
+      private
+
+      def valeur(value) = VALEURS.fetch(value, "inconnu")
+
+      def alerte(settings, app)
+        @paint.red("⚠ active en production") if settings["autoconfirm"] && app.end_with?("-production")
+      end
+    end
+  end
+end

data/lib/captive/shell_completions.rb

@@ -2,13 +2,14 @@
 
 module Captive
   module ShellCompletions
-    ROOT_COMMANDS = %w[apps env crons domains db login whoami console run logs version completions].freeze
+    ROOT_COMMANDS = %w[apps env crons domains addons db login whoami console run logs version completions].freeze
 
     SUBCOMMANDS = {
       "apps" => %w[list info restart rebuild],
       "env"  => %w[list set unset],
       "crons" => %w[list add edit rm suspend resume trigger runs],
       "domains" => %w[list add rm redirect serve],
+      "addons" => %w[list catalog add],
       "db"   => %w[restore],
     }.freeze
 
@@ -25,6 +26,7 @@ module Captive
             env)   COMPREPLY=($(compgen -W "#{SUBCOMMANDS["env"].join(" ")}" -- "$cur")); return ;;
             crons) COMPREPLY=($(compgen -W "#{SUBCOMMANDS["crons"].join(" ")}" -- "$cur")); return ;;
             domains) COMPREPLY=($(compgen -W "#{SUBCOMMANDS["domains"].join(" ")}" -- "$cur")); return ;;
+            addons) COMPREPLY=($(compgen -W "#{SUBCOMMANDS["addons"].join(" ")}" -- "$cur")); return ;;
             db)    COMPREPLY=($(compgen -W "#{SUBCOMMANDS["db"].join(" ")}" -- "$cur")); return ;;
           esac
 

data/lib/captive/sse_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Captive
+  # Découpe un flux Server-Sent Events, reçu par morceaux arbitraires, en événements
+  # `{ id:, data: }`. Les commentaires (`:`, battements de cœur) et `retry` sont ignorés.
+  class SseParser
+    def initialize
+      @buffer = +""
+    end
+
+    def feed(chunk)
+      @buffer << chunk
+      while (fin = @buffer.index("\n\n"))
+        event = self.class.parse(@buffer.slice!(0, fin + 2))
+        yield event if event[:data]
+      end
+    end
+
+    def self.parse(bloc)
+      bloc.each_line(chomp: true).each_with_object({}) do |ligne, event|
+        champ, valeur = ligne.split(": ", 2)
+        event[champ.to_sym] = valeur if %w[id data].include?(champ)
+      end
+    end
+  end
+end

data/lib/captive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Captive
-  VERSION = "1.4.0"
+  VERSION = "1.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: captive-cli
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Captive Studio
@@ -107,6 +107,7 @@ files:
 - lib/captive/cli.rb
 - lib/captive/cli/dependencies.rb
 - lib/captive/cluster_endpoint.rb
+- lib/captive/commands/addons_commands.rb
 - lib/captive/commands/apps_commands.rb
 - lib/captive/commands/apps_restart.rb
 - lib/captive/commands/auth_commands.rb
@@ -131,6 +132,7 @@ files:
 - lib/captive/commands/user_login.rb
 - lib/captive/credentials.rb
 - lib/captive/credentials_store.rb
+- lib/captive/dashboard/addons_resource.rb
 - lib/captive/dashboard/app_path.rb
 - lib/captive/dashboard/apps_resource.rb
 - lib/captive/dashboard/domains_resource.rb
@@ -146,18 +148,21 @@ files:
 - lib/captive/kubectl.rb
 - lib/captive/loader.rb
 - lib/captive/log_noise_filter.rb
+- lib/captive/log_stream.rb
 - lib/captive/null_log_filter.rb
 - lib/captive/one_off_spec.rb
 - lib/captive/poller.rb
+- lib/captive/presenter/addon.rb
 - lib/captive/presenter/ansi_stripper.rb
 - lib/captive/presenter/app_info.rb
 - lib/captive/presenter/domain.rb
 - lib/captive/presenter/log_colorizer.rb
-- lib/captive/presenter/log_line.rb
 - lib/captive/presenter/scheduled_task.rb
+- lib/captive/presenter/supabase_auth.rb
 - lib/captive/session_id.rb
 - lib/captive/session_token.rb
 - lib/captive/shell_completions.rb
+- lib/captive/sse_parser.rb
 - lib/captive/terminal.rb
 - lib/captive/token_refresher.rb
 - lib/captive/ui/banner.rb

data/lib/captive/presenter/log_line.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "captive/log_utils"
-require_relative "log_colorizer"
-
-module Captive
-  module Presenter
-    # Parses a raw kubectl log line and renders it as a colorized terminal string.
-    class LogLine
-      BRACKET_RE = /\A\[(?:pod\/)?(?<pod>[^\/\]]+)(?:\/(?<container>[^\/\]]+))?\]\z/
-
-      def initialize(app:, paint: Pastel.new)
-        @app       = app
-        @colorizer = LogColorizer.new(paint: paint)
-      end
-
-      def call(raw_line)
-        line = raw_line.chomp
-        first, second, message = line.split(" ", 3)
-        return line if first.nil? || second.nil? || message.nil?
-
-        bracket, ts = pick_bracket_and_timestamp(first, second)
-        return line unless bracket
-
-        label = LogUtils::ProcessLabel.for(pod: bracket[:pod], namespace: @app, container: bracket[:container])
-        @colorizer.format_line(ts: ts, label: label, message: message)
-      end
-
-      private
-
-      def pick_bracket_and_timestamp(first, second)
-        if (bracket = BRACKET_RE.match(first))
-          [ bracket, second ]
-        elsif (bracket = BRACKET_RE.match(second))
-          [ bracket, first ]
-        end
-      end
-    end
-  end
-end