captive-cli 1.0.0

data/lib/captive/log_noise_filter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Captive
+  # Écarte le bruit d'infrastructure des logs applicatifs.
+  #
+  # La readinessProbe frappe /up toutes les 3s : Rails tait la requête
+  # (silence_healthcheck_path) mais rack-timeout logge son propre couple
+  # ready/completed, soit ~40 lignes/minute et par pod qui noient les lignes
+  # utiles. Les états timed_out et expired, eux, signalent un incident réel et
+  # restent affichés.
+  class LogNoiseFilter
+    SILENCED_STATES = %w[ready active completed].freeze
+    RACK_TIMEOUT_STATE = /source=rack-timeout\b.*\bstate=(?:#{SILENCED_STATES.join("|")})\b/
+
+    def noise?(line) = RACK_TIMEOUT_STATE.match?(line)
+  end
+end

data/lib/captive/null_log_filter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Captive
+  # Filtre neutre : --raw affiche le flux kubectl tel quel.
+  class NullLogFilter
+    def noise?(_line) = false
+  end
+end

data/lib/captive/one_off_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Captive
+  # Construit le manifeste Job one-off à partir du Deployment web courant.
+  # Labels app: <app>-run pour ne jamais entrer dans le Service web (app=<app>).
+  #
+  # Toujours un Job, même pour la console interactive : ttlSecondsAfterFinished
+  # laisse vivre le pod terminé — donc son log — quelques minutes après la
+  # sortie, ce qu'un Pod nu ne sait pas faire (pas de TTL sur un Pod).
+  class OneOffSpec
+    CONTAINER_NAME = "one-off"
+    CONSOLE_DEADLINE_SECONDS = 4 * 3600
+    RUN_DEADLINE_SECONDS = 3600
+    TTL_SECONDS = 600
+
+    PRODUCTION_NODE_AFFINITY = {
+      "nodeAffinity" => {
+        "requiredDuringSchedulingIgnoredDuringExecution" => {
+          "nodeSelectorTerms" => [
+            {
+              "matchExpressions" => [
+                {
+                  "key" => "captive.dev/workload",
+                  "operator" => "In",
+                  "values" => [ "production" ],
+                },
+              ],
+            },
+          ],
+        },
+      },
+    }.freeze
+
+    def initialize(app:, deployment:, command:, interactive: false, session: nil)
+      @app = app
+      @deployment = deployment
+      @command = Array(command)
+      @interactive = interactive
+      @session = session
+    end
+
+    def to_h = job_manifest
+
+    def self.run_app_label(app)
+      "#{app}-run"
+    end
+
+    def self.live_logs_selector(app)
+      "app in (#{app},#{run_app_label(app)})"
+    end
+
+    private
+
+    def job_manifest
+      {
+        "apiVersion" => "batch/v1",
+        "kind" => "Job",
+        "metadata" => metadata,
+        "spec" => {
+          "backoffLimit" => 0,
+          "ttlSecondsAfterFinished" => TTL_SECONDS,
+          "activeDeadlineSeconds" => deadline,
+          "template" => {
+            "metadata" => { "labels" => labels },
+            "spec" => pod_spec,
+          },
+        },
+      }
+    end
+
+    def deadline = @interactive ? CONSOLE_DEADLINE_SECONDS : RUN_DEADLINE_SECONDS
+
+    # Nommé, et non `generateName`, dès qu'une session est donnée : le pod hérite du nom du
+    # Job en préfixe, ce qui rend la session retrouvable dans Loki sur le seul label `pod`.
+    # Sans session on garde `generateName`, qui ne suppose rien de l'appelant.
+    def metadata
+      base = { "namespace" => @app, "labels" => labels }
+      return base.merge("generateName" => "#{run_label}-") unless @session
+
+      base.merge("name" => "#{run_label}-#{@session}")
+    end
+
+    def labels
+      {
+        "app" => run_label,
+        "captive.dev/type" => "one-off",
+      }
+    end
+
+    def run_label
+      self.class.run_app_label(@app)
+    end
+
+    def pod_spec
+      template = @deployment.dig("spec", "template", "spec") || {}
+      source = primary_container(template)
+
+      spec = {
+        "restartPolicy" => "Never",
+        "imagePullSecrets" => image_pull_secrets(template),
+        "containers" => [ container(source) ],
+        "affinity" => node_affinity(template),
+      }
+      priority = template["priorityClassName"]
+      spec["priorityClassName"] = priority if priority
+      spec
+    end
+
+    def primary_container(template)
+      containers = template["containers"] || []
+      containers.first || raise(ArgumentError, "Deployment '#{@app}' sans container")
+    end
+
+    def container(source)
+      c = {
+        "name" => CONTAINER_NAME,
+        "image" => source.fetch("image"),
+        "command" => @command,
+      }
+      c["env"] = source["env"] if source["env"]
+      c["envFrom"] = source["envFrom"] if source["envFrom"]
+      c["resources"] = source["resources"] if source["resources"]
+      if @interactive
+        c["stdin"] = true
+        c["tty"] = true
+      end
+      c
+    end
+
+    def image_pull_secrets(template)
+      secrets = template["imagePullSecrets"]
+      return secrets if secrets && !secrets.empty?
+
+      [ { "name" => "ghcr-auth" } ]
+    end
+
+    def node_affinity(template)
+      existing = template.dig("affinity", "nodeAffinity")
+      return { "nodeAffinity" => existing } if existing
+
+      PRODUCTION_NODE_AFFINITY
+    end
+  end
+end

data/lib/captive/platform_root.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "errors"
+
+module Captive
+  # Où est le clone de captive-platform. Installé en gem, le CLI ne vit plus dans le monorepo :
+  # la racine se trouve en remontant depuis le dossier courant, comme git trouve .git, ou se
+  # désigne par CAPTIVE_PLATFORM_ROOT. Seul `apps rebuild` en a encore besoin (ADR 0018).
+  module PlatformRoot
+    ENV_VAR = "CAPTIVE_PLATFORM_ROOT"
+
+    def self.find(start: Dir.pwd, env: ENV)
+      env[ENV_VAR] || ascend(start) ||
+        raise(PlatformRootNotFound, "Clone de captive-platform introuvable depuis #{start}. " \
+                                    "Lance la commande depuis le clone ou définis #{ENV_VAR}.")
+    end
+
+    def self.ascend(start)
+      Pathname.new(start).realpath.ascend
+              .find { |dir| dir.join("services").directory? && dir.join(".sops.yaml").file? }&.to_s
+    end
+    private_class_method :ascend
+  end
+end

data/lib/captive/poller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Captive
+  class Poller
+    def initialize(interval:, timeout:, sleeper: method(:sleep), clock: -> { Time.now })
+      @interval = interval
+      @timeout  = timeout
+      @sleeper  = sleeper
+      @clock    = clock
+    end
+
+    def poll_until(context: nil, on_tick: nil, &block)
+      start    = @clock.call
+      deadline = start + @timeout
+      loop do
+        return true if block.call
+
+        now = @clock.call
+        raise PollTimeout, timeout_message(context) if now >= deadline
+
+        on_tick&.call(now - start)
+        @sleeper.call(@interval)
+      end
+    end
+
+    private
+
+    def timeout_message(context)
+      msg = "timeout après #{@timeout}s"
+      context ? "#{msg} — #{context}" : msg
+    end
+  end
+end

data/lib/captive/presenter/ansi_stripper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # Retire les séquences d'échappement terminal d'une ligne de log.
+    #
+    # Une console one-off est attachée à un TTY : IRB redessine son prompt à
+    # chaque frappe et le log du container capture tout (CSI, OSC, requêtes de
+    # position du curseur, retours chariot). Sans ce nettoyage, une ligne de
+    # console est illisible. Le CLI recolorise lui-même, la couleur d'origine
+    # n'a donc rien à conserver.
+    class AnsiStripper
+      CSI = /\e\[[0-?]*[ -\/]*[@-~]/
+      OSC = /\e\][^\a\e]*(?:\a|\e\\)/
+      SINGLE = /\e[@-Z\\-_]/
+      CARRIAGE_RETURN = /\r/
+      SEQUENCES = Regexp.union(CSI, OSC, SINGLE, CARRIAGE_RETURN)
+
+      def call(message) = message.gsub(SEQUENCES, "")
+    end
+  end
+end

data/lib/captive/presenter/log_colorizer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "time"
+require "captive/log_utils"
+require_relative "ansi_stripper"
+
+module Captive
+  module Presenter
+    # Renders a log line as a colorized terminal string using Pastel and LogUtils.
+    class LogColorizer
+      TIME_FORMAT = "%Y-%m-%d %H:%M:%S.%N %z %Z"
+
+      PASTEL_COLORS = {
+        "blue"    => :blue,
+        "green"   => :green,
+        "yellow"  => :yellow,
+        "red"     => :red,
+        "magenta" => :magenta,
+        "dim"     => :bright_black,
+      }.freeze
+
+      def initialize(paint: Pastel.new, stripper: AnsiStripper.new)
+        @paint = paint
+        @stripper = stripper
+      end
+
+      def format_line(ts:, label:, message:)
+        "#{dim_time(ts)} #{badge(label)} #{colorize_message(message)}"
+      end
+
+      private
+
+      def dim_time(ts)
+        formatted = Time.iso8601(ts).localtime.strftime(TIME_FORMAT)
+        @paint.dim(formatted)
+      rescue ArgumentError
+        @paint.dim(ts)
+      end
+
+      def badge(label)
+        color = PASTEL_COLORS.fetch(LogUtils::Colors.for_process(label), :white)
+        @paint.decorate("[#{label}]", color)
+      end
+
+      def colorize_message(raw)
+        message = @stripper.call(raw)
+        level = LogUtils::LogLevelDetector.call(message)
+        color = PASTEL_COLORS[LogUtils::Colors.for_level(level)]
+        color ? @paint.decorate(message, color) : message
+      end
+    end
+  end
+end

data/lib/captive/presenter/log_line.rb

@@ -0,0 +1,40 @@
+# 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

data/lib/captive/session_id.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Captive
+  # L'identifiant qu'une session one-off se donne avant d'exister.
+  #
+  # Il est tiré côté client, et non déduit du Job créé, parce que l'accès est inscrit au fil
+  # d'activité *avant* l'action : à cet instant le Job n'existe pas encore, et une console
+  # abandonnée doit quand même laisser une trace qu'on saura relier à son log.
+  #
+  # Il nomme ensuite le Job, dont le pod hérite le préfixe — c'est ce qui permet au dashboard
+  # de retrouver la session dans Loki par le seul label `pod`, sans que la collecte ait à
+  # promouvoir quoi que ce soit.
+  module SessionId
+    BYTES = 4
+
+    def self.generate = SecureRandom.hex(BYTES)
+  end
+end

data/lib/captive/shell_completions.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Captive
+  module ShellCompletions
+    ROOT_COMMANDS = %w[apps env db login whoami console run logs version completions].freeze
+
+    SUBCOMMANDS = {
+      "apps" => %w[list info restart rebuild],
+      "env"  => %w[list],
+      "db"   => %w[restore],
+    }.freeze
+
+    def self.bash
+      all = (ROOT_COMMANDS + SUBCOMMANDS.values.flatten).uniq.join(" ")
+      <<~BASH
+        _captive_completions() {
+          local cur prev words
+          cur="${COMP_WORDS[COMP_CWORD]}"
+          prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+          case "$prev" in
+            apps)  COMPREPLY=($(compgen -W "#{SUBCOMMANDS["apps"].join(" ")}" -- "$cur")); return ;;
+            env)   COMPREPLY=($(compgen -W "#{SUBCOMMANDS["env"].join(" ")}" -- "$cur")); return ;;
+            db)    COMPREPLY=($(compgen -W "#{SUBCOMMANDS["db"].join(" ")}" -- "$cur")); return ;;
+          esac
+
+          COMPREPLY=($(compgen -W "#{ROOT_COMMANDS.join(" ")}" -- "$cur"))
+        }
+        complete -F _captive_completions captive
+      BASH
+    end
+
+    def self.zsh
+      sub_cases = SUBCOMMANDS.map do |cmd, subs|
+        "      #{cmd}) compadd #{subs.join(" ")} ;;"
+      end.join("\n")
+
+      <<~ZSH
+        _captive() {
+          local state
+
+          _arguments \\
+            '1: :->command' \\
+            '*: :->args'
+
+          case $state in
+            command)
+              compadd #{ROOT_COMMANDS.join(" ")}
+              ;;
+            args)
+              case ${words[2]} in
+        #{sub_cases}
+              esac
+              ;;
+          esac
+        }
+        compdef _captive captive
+      ZSH
+    end
+  end
+end

data/lib/captive/terminal.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Captive
+  # Distingue un humain devant son terminal d'un agent, d'une CI ou d'un pipe.
+  module Terminal
+    def self.interactive?
+      $stdin.tty? && $stdout.tty?
+    end
+  end
+end

data/lib/captive/ui/banner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Captive
+  module UI
+    # L'enseigne posée en haut d'une session interactive — console ou shell.
+    #
+    # Elle ne sert à rien d'autre qu'à dire où l'on vient d'atterrir : une console distante
+    # ressemble à s'y méprendre à un terminal local, et on s'y croit chez soi. Le nom de l'app
+    # à côté de l'enseigne est le seul vrai renseignement de l'affichage.
+    class Banner
+      # Chaque lettre est tracée sur une grille de cinq lignes, pleins uniquement : les
+      # caractères de filet donnaient des angles bricolés à cette taille, là où un pixel plein
+      # n'a pas de forme à rater. Les deux signes du logo y sont — le `/` à la place du `I`,
+      # et le `A` sans barre, qui est le `V` retourné.
+      ART = <<~ART
+        ████   █   ████ █████     █ █   █ ████
+        █     █ █  █  █   █      █  █   █ █
+        █     █ █  ████   █     █   █   █ ███
+        █    █   █ █      █    █     █ █  █
+        ████ █   █ █      █   █       █   ████
+      ART
+
+      def initialize(output: $stdout, paint: Pastel.new)
+        @output = output
+        @paint  = paint
+      end
+
+      def show(app)
+        @output.puts(@paint.cyan(ART))
+        @output.puts(@paint.dim("  #{app}"))
+        @output.puts
+      end
+    end
+  end
+end

data/lib/captive/ui/spinner.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+
+module Captive
+  module UI
+    class Spinner
+      def initialize(label, tty_spinner: nil)
+        @tty_spinner = tty_spinner || TTY::Spinner.new("  [:spinner] #{label}", format: :dots)
+      end
+
+      def run(success_msg:)
+        @tty_spinner.auto_spin
+        result = yield
+        @tty_spinner.success(success_msg)
+        result
+      rescue => e
+        @tty_spinner.error
+        raise
+      end
+    end
+  end
+end

data/lib/captive/update_checker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "http_client"
+require_relative "version"
+
+module Captive
+  class UpdateChecker
+    VERSION_ENDPOINT = "https://raw.githubusercontent.com/captive-studio/homebrew-tap/main/version.json"
+    CACHE_TTL        = 86_400 # 24h en secondes
+
+    def initialize(http: HttpClient.new, cache_path: default_cache_path, current_version: VERSION)
+      @http            = http
+      @cache_path      = cache_path
+      @current_version = Gem::Version.new(current_version)
+    end
+
+    def check
+      data   = fetch_version_data
+      latest  = Gem::Version.new(data["latest"])
+      minimum = Gem::Version.new(data["minimum"])
+
+      return :blocked           if @current_version < minimum
+      return :update_available  if @current_version < latest
+
+      :up_to_date
+    rescue StandardError
+      :up_to_date
+    end
+
+    private
+
+    def fetch_version_data
+      cached = read_cache
+      return cached if cached
+
+      data = @http.get(VERSION_ENDPOINT)
+      write_cache(data)
+      data
+    end
+
+    def read_cache
+      return unless File.exist?(@cache_path)
+
+      raw  = JSON.parse(File.read(@cache_path))
+      age  = Time.now - Time.parse(raw["checked_at"])
+      raw if age < CACHE_TTL
+    rescue StandardError
+      nil
+    end
+
+    def write_cache(data)
+      FileUtils.mkdir_p(File.dirname(@cache_path))
+      File.write(@cache_path, JSON.generate(data.merge("checked_at" => Time.now.iso8601)))
+    rescue StandardError
+      nil
+    end
+
+    def default_cache_path
+      File.expand_path("~/.config/captive/last_update_check")
+    end
+  end
+end

data/lib/captive/version.rb

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