captive-cli 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ec4e1f102b8ed8f597677d727876ad7a0be2996de6cd51de68cb1e4730953e2
-  data.tar.gz: 2a7e112840ea957652e340a70d9586328a65e95cf154b6d5de1a7b3f518a400b
+  metadata.gz: 29616a82b79478784474098a994449670c0e5ba17c4ddbc10b773168adbd5480
+  data.tar.gz: 5dfa16e3181afafa0f3800bfbacce3b07ab0eac18f3863a785b58b66fa4726d4
 SHA512:
-  metadata.gz: 84a84d1504ace4bc7ddfc544a930df455297e4f806509f387241371f6f0f256b7ad2d0aee1ed870fc494a9a93eed36ee33e601808f7ee4363b62908e241076f6
-  data.tar.gz: c5ba6f27ac8b9efb857b62c2f241ade477b976717f5225e4e1423b4be3407a88cadb89dc151e220394efa8d5e09c2bae28e215b491258148ba367adc0f046046
+  metadata.gz: 66462246f725f169bdd2c74e41bf896774fc821961afd12171455b1c4ce2ef94006c3f091203bb7495f8ba70e97e15a6c194ac21100a38b3072c8c6f960f8955
+  data.tar.gz: 4c78529a60c79c0021dcb53a8f124b9fd4a706caa05cb22bb65a4f3a25687b0c288f329301c51628c6f9b216822d7ddbc3e745698f609c2834dc181d93eaef12

data/lib/captive/cli/dependencies.rb

@@ -2,18 +2,28 @@
 
 module Captive
   module CLIDependencies
+    # Les écritures du dashboard sont appliquées plus tard par captive-platform (réponse 202).
+    ASYNC_NOTICE = "demande envoyée, appliquée sous quelques minutes"
+
     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")
+        unless binary_on_path?("kubectl")
+          raise MissingDependencyError, "kubectl introuvable. Installe-le : brew install kubernetes-cli"
+        end
+
+        Kubectl.new(kubeconfig: active_kubeconfig)
       end
     end
-    def gh_cli    = @gh_cli    ||= GhCLI.new
     def trail     = @trail     ||= ActivityTrail.new
     def paint     = @paint     ||= Pastel.new
+    def dashboard = @dashboard ||= DashboardApi.new
+    def apps_api  = @apps_api  ||= Dashboard::AppsResource.new(api: dashboard)
+    def env_api   = @env_api   ||= Dashboard::EnvVarsResource.new(api: dashboard)
+    def crons_api = @crons_api ||= Dashboard::ScheduledTasksResource.new(api: dashboard)
 
     def active_kubeconfig
       env_kc = ENV["KUBECONFIG"]

data/lib/captive/cli.rb

@@ -4,7 +4,8 @@ require "time"
 require_relative "loader"
 require_relative "cli/dependencies"
 require_relative "commands/apps_commands"
-require_relative "commands/env_kube_commands"
+require_relative "commands/env_commands"
+require_relative "commands/crons_commands"
 require_relative "commands/db_commands"
 require_relative "commands/user_login"
 require_relative "dashboard_client"
@@ -30,7 +31,7 @@ module Captive
         warn "⚠ Nouvelle version disponible. Mettez à jour : brew upgrade captive-studio/tap/captive-cli"
       end
       super
-    rescue AuthError, NotAuthenticatedError, NoTtyError => e
+    rescue AuthError, NotAuthenticatedError, NoTtyError, MissingDependencyError, DashboardError => e
       warn e.message
       exit 1
     rescue StandardError => e
@@ -47,7 +48,10 @@ module Captive
     subcommand "db", Commands::DbCommands
 
     desc "env SUBCOMMAND", "Variables d'environnement d'une app"
-    subcommand "env", Commands::EnvKubeCommands
+    subcommand "env", Commands::EnvCommands
+
+    desc "crons SUBCOMMAND", "Tâches planifiées d'une app"
+    subcommand "crons", Commands::CronsCommands
 
     # ── Root commands ────────────────────────────────────────────────────────
     map "--version" => :version
@@ -102,9 +106,10 @@ module Captive
       exit(exit_code) if exit_code && exit_code != 0
     end
 
-    desc "whoami", "Affiche l'identité K8s courante"
+    desc "whoami", "Affiche l'utilisateur connecté au dashboard"
     def whoami
-      puts kubectl.run("auth", "whoami")
+      me = dashboard.get("/me")
+      puts [ me["login"], ("(#{me["name"]})" if me["name"]) ].compact.join(" ")
     end
 
     desc "completions SHELL", "Génère le script de complétion shell (bash ou zsh)"

data/lib/captive/commands/apps_commands.rb

@@ -5,99 +5,74 @@ module Captive
     class AppsCommands < Thor
       include CLIDependencies
 
+      STAGE_BADGES = { "staging" => [ :yellow, "[staging]" ], "production" => [ :green, "[prod]" ] }.freeze
+
       def self.exit_on_failure? = true
 
-      desc "list", "Liste toutes les apps déployées sur la plateforme"
+      desc "list", "Liste les apps auxquelles tu as accès"
       long_desc <<~DESC
-        Liste les apps déployées sur le cluster, avec leurs domaines et leur stage.
+        Liste les apps de tes Organizations, avec leur stage et leur URL (API du dashboard).
 
         \x05Exemple :
         \x05  captive apps list
       DESC
       def list
-        apps = ClusterApps.new(kubectl: kubectl).all
+        apps = apps_api.list
         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
+          puts "  - #{paint.bold(app["name"])}#{stage_badge(app["stage"])}"
+          puts app["app_url"] ? "      #{paint.cyan(app["app_url"])}" : paint.dim("      <no domain>")
         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.
+        Affiche stage, statut, URL, processus (replicas prêts, tier), datastores et domaines.
 
         \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
+        lines = Presenter::AppInfo.new(paint: paint).lines(
+          app: apps_api.show(app), workloads: apps_api.workloads(app).fetch("workloads", []),
+          datastores: apps_api.datastores(app), domains: apps_api.domains(app)
+        )
+        puts lines
       end
 
-      desc "restart APP", "Redémarre le deployment"
+      desc "restart APP", "Redémarre les processus de l'app"
       long_desc <<~DESC
-        Rollout restart du deployment + attend pod Ready.
+        Demande le redémarrage au dashboard, puis attend (120 s max) que tous les
+        processus soient de nouveau prêts.
 
         \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)
+        AppsRestart.new(apps: apps_api).run(app)
         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"
+      desc "rebuild APP", "Redéploie l'app sans changer le code"
       long_desc <<~DESC
-        workflow_dispatch sur le repo GitHub. Utile après changement d'env vars.
+        Relance le build et le déploiement de la version courante via le dashboard.
+        Utile après un changement de variables d'environnement.
 
         \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}")
+        apps_api.redeploy(app)
+        puts paint.green("  ✓ Redéploiement déclenché pour '#{app}'")
       end
 
       private
 
-      def format_age(created_at)
-        return "?" unless created_at
-
-        require "time"
-        "#{((Time.now - Time.parse(created_at)) / 60).round}s"
-      rescue ArgumentError
-        "?"
+      def stage_badge(stage)
+        color, label = STAGE_BADGES[stage]
+        color ? " #{paint.public_send(color, label)}" : ""
       end
     end
   end

data/lib/captive/commands/apps_restart.rb

@@ -1,23 +1,37 @@
 # frozen_string_literal: true
 
+require "time"
 require_relative "../poller"
 require_relative "../errors"
 
 module Captive
   module Commands
+    # Demande le redémarrage au dashboard, puis attend que chaque workload ait tous ses
+    # replicas prêts, sur des pods créés après la demande : juste après le POST, les anciens
+    # pods sont encore prêts et le redémarrage paraîtrait déjà fini.
     class AppsRestart
-      def initialize(kubectl:, poller: nil)
-        @kubectl = kubectl
-        @poller  = poller || Poller.new(interval: 5, timeout: 120)
+      def initialize(apps:, poller: nil)
+        @apps   = apps
+        @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
+        restarted_at = Time.parse(@apps.restart(app).fetch("restarted_at"))
+        @poller.poll_until(context: "redémarrage de #{app}") { restarted?(app, restarted_at) }
+      end
+
+      private
+
+      def restarted?(app, restarted_at)
+        state     = @apps.workloads(app)
+        workloads = state.fetch("workloads", [])
+        workloads.any? && workloads.all? { |w| w["ready"] == w["total"] } &&
+          state.fetch("pods", []).all? { |pod| fresh?(pod, restarted_at) }
+      end
+
+      def fresh?(pod, restarted_at)
+        created_at = pod["created_at"]
+        created_at.nil? || Time.parse(created_at.to_s) >= restarted_at
       end
     end
   end

data/lib/captive/commands/cron_declaration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Captive
+  module Commands
+    # Le corps d'une tâche planifiée à déclarer : les options données sur la ligne de
+    # commande, posées sur une base (les défauts du dashboard pour un ajout, la tâche
+    # actuelle pour une édition).
+    class CronDeclaration
+      DEFAULTS = { "schedule" => "", "timezone" => "Etc/UTC", "mode" => "http", "target" => "",
+                   "timeout_seconds" => 60, "suspended" => false, }.freeze
+      OPTIONS = { schedule: "schedule", timezone: "timezone", mode: "mode", target: "target",
+                  timeout: "timeout_seconds", suspended: "suspended", }.freeze
+
+      def initialize(name, base: DEFAULTS)
+        @name = name
+        @base = base
+      end
+
+      def with(options)
+        given = OPTIONS.filter_map { |option, field| [ field, options[option] ] unless options[option].nil? }
+        DEFAULTS.merge(@base.slice(*DEFAULTS.keys)).merge(given.to_h).merge("name" => @name)
+      end
+    end
+  end
+end

data/lib/captive/commands/crons_commands.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "cron_declaration"
+
+module Captive
+  module Commands
+    class CronsCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      DECLARATION_OPTIONS = {
+        schedule:  { type: :string,  desc: "Planning cron à 5 champs, ex. \"0 3 * * *\"" },
+        target:    { type: :string,  desc: "URL (mode http) ou commande (mode command)" },
+        mode:      { type: :string,  enum: %w[http command], desc: "http (défaut) ou command" },
+        timezone:  { type: :string,  desc: "Fuseau IANA (défaut Etc/UTC)" },
+        timeout:   { type: :numeric, desc: "Durée max en secondes, 1 à 3600 (défaut 60)" },
+        suspended: { type: :boolean, desc: "Déclare la tâche suspendue" },
+      }.freeze
+
+      def self.declaration_options
+        DECLARATION_OPTIONS.each { |name, settings| method_option(name, **settings) }
+      end
+
+      desc "list APP", "Liste les tâches planifiées de l'app"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons list my-app
+      DESC
+      def list(app)
+        tasks = crons_api.list(app)
+        return puts(paint.dim("Aucune tâche planifiée.")) if tasks.empty?
+
+        tasks.each { |task| puts presenter.lines(task) }
+      end
+
+      desc "add APP NAME --schedule CRON --target CIBLE", "Déclare une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons add my-app nettoyage --schedule "0 3 * * *" --target /cron/cleanup
+        \x05  captive crons add my-app purge --schedule "*/15 * * * *" --mode command --target "bin/rails purge"
+      DESC
+      declaration_options
+      def add(app, name)
+        crons_api.create(app, CronDeclaration.new(name).with(options.transform_keys(&:to_sym)))
+        accepted("#{name} déclarée")
+      end
+
+      desc "edit APP NAME [options]", "Modifie une tâche planifiée"
+      long_desc <<~DESC
+        Les options absentes gardent la valeur actuelle de la tâche.
+
+        \x05Exemple :
+        \x05  captive crons edit my-app nettoyage --schedule "0 4 * * *"
+      DESC
+      declaration_options
+      def edit(app, name)
+        base = crons_api.find(app, name)
+        crons_api.update(app, name, CronDeclaration.new(name, base: base).with(options.transform_keys(&:to_sym)))
+        accepted("#{name} modifiée")
+      end
+
+      desc "rm APP NAME", "Supprime une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons rm my-app nettoyage
+      DESC
+      def rm(app, name)
+        crons_api.delete(app, name)
+        accepted("#{name} supprimée")
+      end
+
+      desc "suspend APP NAME", "Suspend une tâche planifiée"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons suspend my-app nettoyage
+      DESC
+      def suspend(app, name)
+        crons_api.suspend(app, name)
+        accepted("#{name} suspendue")
+      end
+
+      desc "resume APP NAME", "Reprend une tâche planifiée suspendue"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons resume my-app nettoyage
+      DESC
+      def resume(app, name)
+        crons_api.resume(app, name)
+        accepted("#{name} reprise")
+      end
+
+      desc "trigger APP NAME", "Lance une tâche planifiée maintenant"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive crons trigger my-app nettoyage
+      DESC
+      def trigger(app, name)
+        job = crons_api.trigger(app, name).fetch("job_name")
+        puts paint.green("  ✓ #{name} lancée (job #{job})")
+      end
+
+      desc "runs APP NAME", "Affiche la dernière exécution d'une tâche"
+      long_desc <<~DESC
+        Le cluster ne garde que la dernière exécution (un succès disparaît après 5 minutes).
+
+        \x05Exemple :
+        \x05  captive crons runs my-app nettoyage
+      DESC
+      def runs(app, name)
+        puts presenter.last_run(crons_api.find(app, name)["last_run"]).strip
+      end
+
+      private
+
+      def presenter = Presenter::ScheduledTask.new(paint: paint)
+
+      def accepted(message)
+        puts paint.green("  ✓ #{message} : #{ASYNC_NOTICE}")
+      end
+    end
+  end
+end

data/lib/captive/commands/env_commands.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "env_set"
+
+module Captive
+  module Commands
+    class EnvCommands < Thor
+      include CLIDependencies
+
+      def self.exit_on_failure? = true
+
+      desc "list APP", "Liste les variables d'environnement de l'app"
+      long_desc <<~DESC
+        Lit les variables via le dashboard. Une écriture pas encore appliquée est signalée.
+
+        \x05Exemple :
+        \x05  captive env list my-app-staging
+      DESC
+      def list(app)
+        env_api.list(app).sort_by { |var| var["key"] }.each do |var|
+          puts "#{var["key"]}=#{var["value"]}#{state(var)}"
+        end
+      end
+
+      desc "set APP KEY=VALUE [KEY=VALUE...]", "Crée ou modifie des variables d'environnement"
+      long_desc <<~DESC
+        Crée les clés absentes, met à jour les autres. Appliqué par la plateforme
+        sous quelques minutes.
+
+        \x05Exemple :
+        \x05  captive env set my-app-staging FOO=bar BAZ=qux
+      DESC
+      def set(app, *pairs)
+        abort "Indique au moins une paire KEY=VALUE." if pairs.empty?
+
+        EnvSet.new(env_vars: env_api).run(app, pairs).each do |key, outcome|
+          puts paint.green("  ✓ #{key} #{outcome == :created ? "créée" : "modifiée"}")
+        end
+        puts paint.dim("  #{ASYNC_NOTICE}")
+      end
+
+      desc "unset APP KEY [KEY...]", "Supprime des variables d'environnement"
+      long_desc <<~DESC
+        \x05Exemple :
+        \x05  captive env unset my-app-staging FOO BAZ
+      DESC
+      def unset(app, *keys)
+        abort "Indique au moins une clé." if keys.empty?
+
+        keys.each do |key|
+          env_api.delete(app, key)
+          puts paint.green("  ✓ #{key} supprimée")
+        end
+        puts paint.dim("  #{ASYNC_NOTICE}")
+      end
+
+      private
+
+      def state(var)
+        return paint.red("  [échec : #{var["failure_reason"] || "écriture refusée"}]") if var["failed"]
+
+        var["pending"] ? paint.yellow("  [en attente : #{var["pending_change"]}]") : ""
+      end
+    end
+  end
+end

data/lib/captive/commands/env_set.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Captive
+  module Commands
+    # Écrit des paires KEY=VALUE : une clé déjà présente se met à jour, une nouvelle se crée.
+    class EnvSet
+      def initialize(env_vars:)
+        @env_vars = env_vars
+      end
+
+      # Retourne [[clé, :created|:updated], …] dans l'ordre des paires.
+      def run(app, pairs)
+        parsed   = pairs.map { |pair| parse(pair) }
+        existing = @env_vars.list(app).to_set { |var| var["key"] }
+        parsed.map { |key, value| write(app, key, value, existing.include?(key)) }
+      end
+
+      private
+
+      def parse(pair)
+        key, separator, value = pair.partition("=")
+        raise ValidationError, "Paire invalide : #{pair.inspect}. Attendu KEY=VALUE" if separator.empty? || key.empty?
+
+        [ key, value ]
+      end
+
+      def write(app, key, value, exists)
+        if exists
+          @env_vars.update(app, key, value)
+          [ key, :updated ]
+        else
+          @env_vars.create(app, key, value)
+          [ key, :created ]
+        end
+      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,56 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "token_file"
+require_relative "dashboard_response"
+
+module Captive
+  # Le transport JSON vers l'API du dashboard : jeton GitHub en Bearer, 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: TokenFile.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}")
+      req = build(verb, uri, body)
+      response = @starter.call(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                                   open_timeout: 5, read_timeout: @read_timeout) do |http|
+        http.request(req)
+      end
+      DashboardResponse.new(response).parse
+    end
+
+    def build(verb, uri, body)
+      req = VERBS.fetch(verb).new(uri.request_uri)
+      req["Authorization"] = "Bearer #{@token.read}"
+      req["Accept"] = "application/json"
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+      req
+    end
+  end
+end