captive-cli 1.0.0 → 1.3.0

data/lib/captive/commands/user_login.rb

@@ -9,36 +9,36 @@ module Captive
         def open(url) = system(open_cmd, url)
       end
 
-      def initialize(github:, cluster:, token_path:, kubeconfig_path:,
+      def initialize(github:, cluster:, store:, kubeconfig_path:,
                      ui: method(:puts), browser: Browser.new("open"))
         @github          = github
         @cluster         = cluster
-        @token_path      = token_path
+        @store           = store
         @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)
+        credentials = @github.poll_token(device_code: device[:device_code], interval: device[:interval])
+        @store.write(credentials)
+        write_kubeconfig(@cluster.fetch(credentials.access_token))
       end
 
       private
 
-      def ensure_dirs
-        [ @token_path, @kubeconfig_path ].each { |p| FileUtils.mkdir_p(File.dirname(p)) }
+      def write_kubeconfig(endpoint)
+        FileUtils.mkdir_p(File.dirname(@kubeconfig_path))
+        File.write(@kubeconfig_path, kubeconfig_content(endpoint))
+        File.chmod(0o600, @kubeconfig_path)
       end
 
-      def kubeconfig_content(token)
-        endpoint = @cluster.fetch(token)
+      # Pas de jeton dans le kubeconfig : kubectl demande à `captive auth token` un jeton
+      # renouvelé quand il le faut.
+      def kubeconfig_content(endpoint)
         <<~YAML
           apiVersion: v1
           kind: Config
@@ -50,7 +50,14 @@ module Captive
           users:
             - name: captive-user
               user:
-                token: #{token}
+                exec:
+                  apiVersion: client.authentication.k8s.io/v1
+                  command: captive
+                  args:
+                    - auth
+                    - token
+                  interactiveMode: Never
+                  provideClusterInfo: false
           contexts:
             - name: captive
               context:

data/lib/captive/credentials.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Captive
+  # Les jetons GitHub de l'utilisateur et leurs échéances. Un jeton sans `expires_at` vient d'une
+  # GitHub App sans expiration (ou de l'ancien fichier `token`) : il n'est jamais renouvelé.
+  Credentials = Data.define(:access_token, :refresh_token, :expires_at, :refresh_token_expires_at) do
+    def self.from_github(data, now:)
+      new(access_token:             data.fetch("access_token"),
+          refresh_token:            data["refresh_token"],
+          expires_at:               after(now, data["expires_in"]),
+          refresh_token_expires_at: after(now, data["refresh_token_expires_in"]))
+    end
+
+    def self.from_json_hash(hash)
+      new(access_token:             hash.fetch("access_token"),
+          refresh_token:            hash["refresh_token"],
+          expires_at:               parse_time(hash["expires_at"]),
+          refresh_token_expires_at: parse_time(hash["refresh_token_expires_at"]))
+    end
+
+    def self.after(now, seconds) = seconds && (now + seconds.to_i)
+    def self.parse_time(value)   = value && Time.iso8601(value)
+    private_class_method :after, :parse_time
+
+    def initialize(access_token:, refresh_token: nil, expires_at: nil, refresh_token_expires_at: nil) = super
+
+    # Moins de `margin` secondes de validité : on renouvelle avant qu'une requête n'échoue.
+    def expiring?(now, margin: 300) = expirable? && expires_at - now < margin
+    def expirable?                  = !expires_at.nil?
+    def refreshable?(now)           = !refresh_token.nil? && (refresh_token_expires_at.nil? || refresh_token_expires_at > now)
+
+    def to_json_hash
+      {
+        "access_token"             => access_token,
+        "refresh_token"            => refresh_token,
+        "expires_at"               => expires_at&.utc&.iso8601,
+        "refresh_token_expires_at" => refresh_token_expires_at&.utc&.iso8601,
+      }
+    end
+  end
+end

data/lib/captive/credentials_store.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "securerandom"
+require_relative "credentials"
+require_relative "errors"
+
+module Captive
+  # Où vivent les jetons : `credentials.json` (0600, écrit atomiquement), et en repli l'ancien
+  # fichier `token` des postes qui ne se sont pas reconnectés depuis l'arrivée du renouvellement.
+  class CredentialsStore
+    DIR = File.expand_path("~/.config/captive")
+
+    def initialize(dir: DIR)
+      @path        = File.join(dir, "credentials.json")
+      @legacy_path = File.join(dir, "token")
+      @lock_path   = File.join(dir, "credentials.lock")
+    end
+
+    def read
+      return Credentials.from_json_hash(JSON.parse(File.read(@path))) if File.exist?(@path)
+      return Credentials.new(access_token: File.read(@legacy_path).strip) if File.exist?(@legacy_path)
+
+      raise NotAuthenticatedError, "Pas de session active. Lance : captive login"
+    end
+
+    # Un fichier temporaire renommé : un lecteur concurrent voit l'ancien contenu ou le nouveau,
+    # jamais un fichier à moitié écrit.
+    def write(credentials)
+      FileUtils.mkdir_p(File.dirname(@path))
+      tmp = "#{@path}.#{SecureRandom.hex(4)}.tmp"
+      File.write(tmp, JSON.pretty_generate(credentials.to_json_hash), perm: 0o600)
+      File.rename(tmp, @path)
+    end
+
+    # Verrou inter-processus : deux commandes (ou kubectl et une commande) ne renouvellent pas en
+    # même temps un refresh_token à usage unique.
+    def exclusively
+      FileUtils.mkdir_p(File.dirname(@lock_path))
+      File.open(@lock_path, File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+  end
+end

data/lib/captive/dashboard/apps_resource.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Captive
+  module Dashboard
+    # Les apps vues par le dashboard : leur fiche, ce qui tourne, et les gestes sur l'app.
+    class AppsResource
+      def initialize(api:)
+        @api = api
+      end
+
+      def list           = @api.get("/apps")
+      def show(app)      = @api.get(path(app))
+      def datastores(app) = @api.get("#{path(app)}/datastores").fetch("datastores", [])
+      def domains(app)   = @api.get("#{path(app)}/domains")
+      def restart(app)   = @api.post("#{path(app)}/restart")
+      def redeploy(app)  = @api.post("#{path(app)}/deployments/redeploy")
+
+      # Le dashboard répond null quand le namespace n'a encore rien déployé.
+      def workloads(app) = @api.get("#{path(app)}/workloads") || {}
+
+      private
+
+      def path(app) = "/apps/#{DashboardApi.segment(app)}"
+    end
+  end
+end

data/lib/captive/dashboard/env_vars_resource.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Captive
+  module Dashboard
+    # Les variables d'environnement d'une app : lues du Secret, écrites par set-env.
+    class EnvVarsResource
+      def initialize(api:)
+        @api = api
+      end
+
+      def list(app) = @api.get(path(app))
+
+      def create(app, key, value) = @api.post(path(app), { env_var: { key: key, value: value } })
+
+      def update(app, key, value) = @api.patch(path(app, key), { env_var: { value: value } })
+
+      def delete(app, key) = @api.delete(path(app, key))
+
+      private
+
+      def path(app, key = nil)
+        base = "/apps/#{DashboardApi.segment(app)}/env_vars"
+        key ? "#{base}/#{DashboardApi.segment(key)}" : base
+      end
+    end
+  end
+end

data/lib/captive/dashboard/scheduled_tasks_resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Captive
+  module Dashboard
+    # Les tâches planifiées d'une app : lues du cluster, déclarées via captive-platform.
+    class ScheduledTasksResource
+      def initialize(api:)
+        @api = api
+      end
+
+      def list(app)                   = @api.get(path(app))
+      def create(app, declaration)    = @api.post(path(app), { scheduled_task: declaration })
+      def update(app, name, declaration) = @api.patch(path(app, name), { scheduled_task: declaration })
+      def delete(app, name)           = @api.delete(path(app, name))
+      def suspend(app, name)          = @api.post("#{path(app, name)}/suspension")
+      def resume(app, name)           = @api.delete("#{path(app, name)}/suspension")
+      def trigger(app, name)          = @api.post("#{path(app, name)}/runs")
+
+      def find(app, name)
+        list(app).find { |task| task["name"] == name } ||
+          raise(NotFoundError, "Tâche planifiée « #{name} » introuvable sur #{app}")
+      end
+
+      private
+
+      def path(app, name = nil)
+        base = "/apps/#{DashboardApi.segment(app)}/scheduled_tasks"
+        name ? "#{base}/#{DashboardApi.segment(name)}" : base
+      end
+    end
+  end
+end

data/lib/captive/dashboard_api.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "session_token"
+require_relative "dashboard_response"
+
+module Captive
+  # Le transport JSON vers l'API du dashboard : jeton GitHub en Bearer (rejoué une fois renouvelé
+  # sur un 401), timeouts courts, et
+  # erreurs HTTP traduites par DashboardResponse. Les chemins sont relatifs à /api.
+  class DashboardApi
+    BASE_URL = "https://dashboard.captive.dev"
+    VERBS = {
+      get: Net::HTTP::Get, post: Net::HTTP::Post, patch: Net::HTTP::Patch, delete: Net::HTTP::Delete,
+    }.freeze
+
+    def self.segment(value) = URI.encode_uri_component(value.to_s)
+
+    def initialize(token: SessionToken.new, base_url: BASE_URL, starter: Net::HTTP.method(:start),
+                   read_timeout: 15)
+      @token        = token
+      @base_url     = base_url
+      @starter      = starter
+      @read_timeout = read_timeout
+    end
+
+    def get(path)          = request(:get, path)
+    def post(path, body = nil)  = request(:post, path, body)
+    def patch(path, body = nil) = request(:patch, path, body)
+    def delete(path)       = request(:delete, path)
+
+    private
+
+    def request(verb, path, body = nil)
+      uri = URI.parse("#{@base_url}/api#{path}")
+      response = @token.authorize do |token|
+        @starter.call(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                          open_timeout: 5, read_timeout: @read_timeout) do |http|
+          http.request(build(verb, uri, body, token))
+        end
+      end
+      DashboardResponse.new(response).parse
+    end
+
+    def build(verb, uri, body, token)
+      req = VERBS.fetch(verb).new(uri.request_uri)
+      req["Authorization"] = "Bearer #{token}"
+      req["Accept"] = "application/json"
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+      req
+    end
+  end
+end

data/lib/captive/dashboard_client.rb

@@ -5,22 +5,24 @@ require "uri"
 require "json"
 require "time"
 require_relative "errors"
+require_relative "session_token"
 
 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
+    def initialize(session: SessionToken.new)
+      @session = session
+    end
 
+    def logs(app, start_at: nil, end_at: nil, limit: nil)
       if start_at || end_at
-        fetch_all(app, token, start_at:, end_at:)
+        fetch_all(app, start_at:, end_at:)
       else
         uri      = build_uri(app, limit: limit || PAGE_SIZE)
-        response = get(uri, token)
+        response = get(uri)
         page, _  = extract_page(handle_response(response))
         page
       end
@@ -34,20 +36,20 @@ module Captive
       body[:command] = command if command
       body[:session] = session if session
 
-      post(uri, read_token, body)
+      post(uri, 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:)
+    def fetch_all(app, 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)
+        response = get(uri)
         page, has_more = extract_page(handle_response(response))
 
         break if page.empty?
@@ -74,12 +76,6 @@ module Captive
       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
@@ -90,21 +86,25 @@ module Captive
       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")
+    def get(uri)
+      @session.authorize do |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
     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")
+    def post(uri, body)
+      @session.authorize do |token|
+        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
     end
 

data/lib/captive/dashboard_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "errors"
+require_relative "validation_message"
+
+module Captive
+  # Traduit une réponse HTTP du dashboard : le corps JSON si elle réussit, sinon l'erreur
+  # que l'utilisateur peut comprendre.
+  class DashboardResponse
+    ERRORS = {
+      401 => [ AuthError, "Token invalide ou expiré. Lance : captive login" ],
+      403 => [ ForbiddenError, "Accès refusé : tu n'es pas Membre de l'Organization de cette app." ],
+      404 => [ NotFoundError, "App ou ressource introuvable" ],
+      503 => [ ServiceUnavailableError, "Service indisponible, réessaie" ],
+    }.freeze
+
+    def initialize(response)
+      @code = response.code.to_i
+      @body = response.body.to_s
+    end
+
+    def parse
+      return (@body.strip.empty? ? nil : JSON.parse(@body)) if @code.between?(200, 299)
+      raise ValidationError, ValidationMessage.new(json_body).to_s if @code == 422
+
+      klass, message = ERRORS.fetch(@code) { [ DashboardError, "Erreur dashboard (HTTP #{@code})" ] }
+      raise klass, message
+    end
+
+    private
+
+    def json_body
+      JSON.parse(@body)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/captive/errors.rb

@@ -4,13 +4,24 @@ 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
+
+  # Le refresh_token a expiré ou GitHub le refuse : seul un nouveau `captive login` rétablit l'accès.
+  class SessionExpiredError < AuthError
+    def initialize(message = "Session expirée. Lance : captive login") = super
+  end
   class NoTtyError < StandardError; end
-  class PlatformRootNotFound < StandardError; end
+  class MissingDependencyError < StandardError; end
+
+  # Réponses de l'API du dashboard qui ont un sens pour l'utilisateur : rattrapées par
+  # CLI.start et affichées sans trace.
+  class DashboardError < StandardError; end
+  class ForbiddenError < DashboardError; end
+  class NotFoundError < DashboardError; end
+  class ValidationError < DashboardError; end
+  class ServiceUnavailableError < DashboardError; end
 end

data/lib/captive/flux.rb

@@ -1,15 +1,24 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "errors"
 
 module Captive
   class Flux
     def suspend_kustomization(name)
-      Open3.capture3("flux", "suspend", "kustomization", name)
+      capture("suspend", "kustomization", name)
     end
 
     def resume_kustomization(name)
-      Open3.capture3("flux", "resume", "kustomization", name)
+      capture("resume", "kustomization", name)
+    end
+
+    private
+
+    def capture(*args)
+      Open3.capture3("flux", *args)
+    rescue Errno::ENOENT
+      raise MissingDependencyError, "flux introuvable. Installe-le : brew install flux"
     end
   end
 end

data/lib/captive/github_device_flow.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require_relative "http_client"
+require_relative "credentials"
 
 module Captive
   class GithubDeviceFlow
     CLIENT_ID = "Iv23liHr9n6eK4XhwtnP"
 
-    def initialize(http: HttpClient.new)
-      @http = http
+    def initialize(http: HttpClient.new, clock: -> { Time.now })
+      @http  = http
+      @clock = clock
     end
 
     RETRIABLE_ERRORS = %w[authorization_pending slow_down].freeze
@@ -19,7 +21,7 @@ module Captive
         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"]
+        return Credentials.from_github(data, now: @clock.call) if data["access_token"]
         raise DeviceFlowError, data["error"] unless RETRIABLE_ERRORS.include?(data["error"])
       end
     end

data/lib/captive/kubectl.rb

@@ -237,12 +237,6 @@ module Captive
       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
@@ -291,10 +285,6 @@ module Captive
       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")

data/lib/captive/loader.rb

@@ -6,14 +6,18 @@ 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 "dashboard_api"
+require_relative "dashboard/apps_resource"
+require_relative "dashboard/env_vars_resource"
+require_relative "dashboard/scheduled_tasks_resource"
+require_relative "presenter/app_info"
+require_relative "presenter/scheduled_task"
 require_relative "activity_trail"
 require_relative "errors"
 require_relative "ui/spinner"
@@ -23,9 +27,7 @@ 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"
 

data/lib/captive/presenter/app_info.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # La fiche d'une app telle que `captive apps info` l'affiche, à partir des lectures du
+    # dashboard : l'app, ses workloads, ses datastores et ses domaines.
+    class AppInfo
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def lines(app:, workloads:, datastores:, domains:)
+        [ @paint.bold(app["name"]),
+          "  Stage    : #{app["stage"] || "–"}",
+          "  Statut   : #{app["status"] || "–"}",
+          "  URL      : #{app["app_url"] || "–"}",
+          *section("Processus", workloads.map { |w| workload(w) }),
+          *section("Datastores", datastores.map { |d| "#{d["kind"]} #{d["name"]}" }),
+          *section("Domaines", domains.map { |d| domain(d) }), ]
+      end
+
+      private
+
+      def section(title, items)
+        [ "  #{title} :", *(items.empty? ? [ @paint.dim("    –") ] : items.map { |item| "    #{item}" }) ]
+      end
+
+      def workload(entry)
+        ready = "#{entry["ready"]}/#{entry["total"]}"
+        ready = @paint.yellow(ready) unless entry["ready"] == entry["total"]
+        "#{entry["name"]} #{ready} prêt(s), tier #{entry["tier"] || "–"}"
+      end
+
+      def domain(entry)
+        flags = [ ("principal" if entry["primary"]), ("en attente" if entry["pending"]) ].compact
+        flags.empty? ? entry["hostname"] : "#{entry["hostname"]} (#{flags.join(", ")})"
+      end
+    end
+  end
+end

data/lib/captive/presenter/scheduled_task.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Captive
+  module Presenter
+    # Une tâche planifiée sur une ligne, puis sa dernière exécution si elle a tourné.
+    class ScheduledTask
+      def initialize(paint:)
+        @paint = paint
+      end
+
+      def lines(task)
+        head = "#{@paint.bold(task["name"])}  #{task["schedule"]} (#{task["timezone"]})  " \
+               "#{task["mode"]} #{task["target"]}"
+        head += " #{@paint.yellow("[suspendue]")}" if task["suspended"]
+        [ head, last_run(task["last_run"]) ]
+      end
+
+      # Le cluster ne garde qu'une exécution réussie, cinq minutes : seule la dernière se lit.
+      def last_run(run)
+        return @paint.dim("    aucune exécution récente") unless run
+
+        "    dernière : #{run["started_at"]} → #{run["finished_at"] || "en cours"} #{outcome(run["outcome"])}"
+      end
+
+      private
+
+      def outcome(value)
+        case value
+        when "succeeded" then @paint.green(value)
+        when "failed", "timeout" then @paint.red(value)
+        else value.to_s
+        end
+      end
+    end
+  end
+end